resource/unittests/OCResourceTest.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21
  22 #include <OCPlatform.h>
  23 #include <OCApi.h>
  24 #include <gtest/gtest.h>
  25 #include <string>
  26 #include <map>
  27
  28 namespace OCResourceTest
  29 {
  30     using namespace OC;
  31     // Callbacks
  32     void onObserve(const HeaderOptions, const OCRepresentation&, const int&, const int&)
  33     {
  34     }
  35
  36     void onGetPut(const HeaderOptions&, const OCRepresentation& , const int eCode)
  37     {
  38         EXPECT_EQ(eCode, OC_STACK_OK);
  39     }
  40
  41     void foundResource(std::shared_ptr<OCResource> )
  42     {
  43     }
  44
  45     void deleteResponse(const HeaderOptions&, const int)
  46     {
  47     }
  48
  49     //Helper method
  50     OCResource::Ptr ConstructResourceObject(std::string host, std::string uri)
  51     {
  52         OCConnectivityType connectivityType = OC_WIFI;
  53         std::vector<std::string> types = {"intel.rpost"};
  54         std::vector<std::string> ifaces = {DEFAULT_INTERFACE};
  55
  56         return OCPlatform::constructResourceObject(host, uri,
  57                 connectivityType, false, types, ifaces);
  58     }
  59
  60      //Get Test
  61     TEST(ConstructResourceTest, ConstructResourceObject)
  62     {
  63         EXPECT_ANY_THROW(ConstructResourceObject(std::string(""), std::string("")));
  64     }
  65
  66     TEST(ResourceGetTest, ResourceGetForValidUri)
  67     {
  68         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
  69         EXPECT_TRUE(resource != NULL);
  70         EXPECT_EQ(OC_STACK_OK, resource->get(OC::QueryParamsMap(), &onGetPut));
  71
  72     }
  73
  74     TEST(ResourceGetTest, ResourceGetForBadUri)
  75     {
  76         OCResource::Ptr resource = ConstructResourceObject("", "coap://192.168.1.2:5000");
  77         EXPECT_TRUE(resource != NULL);
  78         EXPECT_THROW(resource->get(OC::QueryParamsMap(), &onGetPut), OC::OCException);
  79     }
  80
  81     // Enable it when the CON is supported in the stack
  82     TEST(ResourceGetTest, DISABLED_ResourceGetWithHighQos)
  83     {
  84         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
  85         EXPECT_TRUE(resource != NULL);
  86         EXPECT_EQ(OC_STACK_OK,
  87                 resource->get(OC::QueryParamsMap(), &onGetPut, QualityOfService::HighQos));
  88     }
  89
  90     TEST(ResourceGetTest, ResourceGetWithLowQos)
  91     {
  92         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
  93         EXPECT_TRUE(resource != NULL);
  94         EXPECT_EQ(OC_STACK_OK,
  95                 resource->get(OC::QueryParamsMap(), &onGetPut, QualityOfService::LowQos));
  96     }
  97
  98     TEST(ResourceGetTest, ResourceGetWithMidQos)
  99     {
 100         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 101         EXPECT_TRUE(resource != NULL);
 102         EXPECT_EQ(OC_STACK_OK,
 103                 resource->get(OC::QueryParamsMap(), &onGetPut, QualityOfService::MidQos));
 104     }
 105
 106     TEST(ResourceGetTest, ResourceGetWithNaQos)
 107     {
 108         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 109         EXPECT_TRUE(resource != NULL);
 110         EXPECT_EQ(OC_STACK_OK,
 111                 resource->get(OC::QueryParamsMap(), &onGetPut, QualityOfService::NaQos));
 112     }
 113
 114     TEST(ResourceGetTest, ResourceGetWithRTIFNaQos)
 115     {
 116         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 117         EXPECT_TRUE(resource != NULL);
 118         EXPECT_EQ(OC_STACK_OK,
 119                 resource->get("", DEFAULT_INTERFACE, QueryParamsMap(), &onGetPut,
 120                         QualityOfService::NaQos));
 121     }
 122
 123     TEST(ResourceGetTest, ResourceGetWithNullResourceType)
 124     {
 125         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 126         EXPECT_TRUE(resource != NULL);
 127         EXPECT_ANY_THROW(
 128                 resource->get(nullptr, DEFAULT_INTERFACE, QueryParamsMap(), &onGetPut,
 129                         QualityOfService::NaQos));
 130     }
 131
 132
 133     TEST(ResourceGetTest, ResourceGetWithNullResourceInterface)
 134     {
 135         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 136         EXPECT_TRUE(resource != NULL);
 137         EXPECT_ANY_THROW(
 138                 resource->get("", nullptr, QueryParamsMap(), &onGetPut, QualityOfService::NaQos));
 139     }
 140
 141     TEST(ResourceGetTest, ResourceGetWithTypeAndInterface)
 142     {
 143         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 144         EXPECT_TRUE(resource != NULL);
 145         EXPECT_EQ(OC_STACK_OK, resource->get("", DEFAULT_INTERFACE, QueryParamsMap(), &onGetPut));
 146     }
 147
 148     //Post Test
 149     TEST(ResourcePostTest, ResourcePostValidConfiguration)
 150     {
 151         OCRepresentation rep;
 152         QueryParamsMap query = {};
 153         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 154         EXPECT_TRUE(resource != NULL);
 155         EXPECT_EQ(OC_STACK_OK, resource->post(rep, query, &onGetPut));
 156     }
 157
 158     TEST(ResourcePostTest, ResourcePostWithNaQos)
 159     {
 160         OCRepresentation rep;
 161         QueryParamsMap query = {};
 162         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 163         EXPECT_TRUE(resource != NULL);
 164         EXPECT_EQ(OC_STACK_OK, resource->post(rep, query, &onGetPut, QualityOfService::NaQos));
 165     }
 166
 167     TEST(ResourcePostTest, ResourcePostWithMidQos)
 168     {
 169         OCRepresentation rep;
 170         QueryParamsMap query = {};
 171         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 172         EXPECT_TRUE(resource != NULL);
 173         EXPECT_EQ(OC_STACK_OK, resource->post(rep, query, &onGetPut, QualityOfService::MidQos));
 174     }
 175
 176     TEST(ResourcePostTest, ResourcePostWithLowQos)
 177     {
 178         OCRepresentation rep;
 179         QueryParamsMap query = {};
 180         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 181         EXPECT_TRUE(resource != NULL);
 182         EXPECT_EQ(OC_STACK_OK, resource->post(rep, query, &onGetPut, QualityOfService::LowQos));
 183     }
 184
 185     // Enable it when the CON is supported in the stack
 186     TEST(ResourcePostTest, DISABLED_ResourcePostWithHighQos)
 187     {
 188         OCRepresentation rep;
 189         QueryParamsMap query = {};
 190         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 191         EXPECT_TRUE(resource != NULL);
 192         EXPECT_EQ(OC_STACK_OK, resource->post(rep, query, &onGetPut, QualityOfService::HighQos));
 193     }
 194
 195     //Put Test
 196     TEST(ResourcePutTest, ResourcePutForValid)
 197     {
 198         OCRepresentation rep;
 199         QueryParamsMap query = {};
 200         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 201         EXPECT_TRUE(resource != NULL);
 202         EXPECT_EQ(OC_STACK_OK, resource->put(rep, query, &onGetPut));
 203     }
 204
 205     TEST(ResourcePutTest, ResourcePutWithNaQos)
 206     {
 207         OCRepresentation rep;
 208         QueryParamsMap query = {};
 209         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 210         EXPECT_TRUE(resource != NULL);
 211         EXPECT_EQ(OC_STACK_OK, resource->put(rep, query, &onGetPut, QualityOfService::NaQos));
 212     }
 213
 214     TEST(ResourcePutTest, ResourcePutWithLowQos)
 215     {
 216         OCRepresentation rep;
 217         QueryParamsMap query = {};
 218         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 219         EXPECT_TRUE(resource != NULL);
 220         EXPECT_EQ(OC_STACK_OK, resource->put(rep, query, &onGetPut, QualityOfService::LowQos));
 221     }
 222
 223     TEST(ResourcePutTest, ResourcePutWithMidQos)
 224     {
 225         OCRepresentation rep;
 226         QueryParamsMap query = {};
 227         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 228         EXPECT_TRUE(resource != NULL);
 229         EXPECT_EQ(OC_STACK_OK, resource->put(rep, query, &onGetPut, QualityOfService::MidQos));
 230     }
 231
 232     // Enable it when the CON is supported in the stack
 233     TEST(ResourcePutTest, DISABLED_ResourcePutWithHighQos)
 234     {
 235         OCRepresentation rep;
 236         QueryParamsMap query = {};
 237         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 238         EXPECT_TRUE(resource != NULL);
 239         EXPECT_EQ(OC_STACK_OK, resource->put(rep, query, &onGetPut, QualityOfService::HighQos));
 240     }
 241
 242     TEST(ResourcePutTest, ResourcePutWithTypeAndInterface)
 243     {
 244         OCRepresentation rep;
 245         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 246         EXPECT_TRUE(resource != NULL);
 247         EXPECT_EQ(OC_STACK_OK,
 248                 resource->put("", DEFAULT_INTERFACE, rep, QueryParamsMap(), &onGetPut));
 249     }
 250
 251     TEST(ResourcePutTest, ResourcePutWithNullType)
 252     {
 253         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 254         EXPECT_TRUE(resource != NULL);
 255         OCRepresentation rep;
 256         EXPECT_ANY_THROW(
 257                 resource->put(nullptr, DEFAULT_INTERFACE, rep, QueryParamsMap(), &onGetPut));
 258         HeaderOptions headerOptions = {};
 259         onGetPut(headerOptions, rep, OC_STACK_OK);
 260     }
 261
 262     TEST(ResourcePutTest, ResourcePutWithNullInterface)
 263     {
 264         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 265         EXPECT_TRUE(resource != NULL);
 266         OCRepresentation rep;
 267         EXPECT_ANY_THROW(resource->put("", nullptr, rep, QueryParamsMap(), &onGetPut));
 268     }
 269
 270     // Observer Test
 271     TEST(ResourceObserveTest, ResourceObserveValidUri)
 272     {
 273         OCResource::Ptr resource =
 274                 ConstructResourceObject("coap://192.168.1.2:5000", "/Observe");
 275         EXPECT_TRUE(resource != NULL);
 276         QueryParamsMap query = {};
 277         EXPECT_EQ(OC_STACK_OK, resource->observe(ObserveType::ObserveAll, query, &onObserve));
 278     }
 279
 280     TEST(ResourceObserveTest, ResourceObserveLoQos)
 281     {
 282         QueryParamsMap query = {};
 283         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/Observe");
 284         EXPECT_TRUE(resource != NULL);
 285         EXPECT_EQ(OC_STACK_OK,
 286                 resource->observe(ObserveType::ObserveAll, query, &onObserve,
 287                         QualityOfService::LowQos));
 288     }
 289
 290     TEST(ResourceObserveTest, ResourceObserveNaQos)
 291     {
 292         QueryParamsMap query = {};
 293         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/Observe");
 294         EXPECT_TRUE(resource != NULL);
 295         EXPECT_EQ(OC_STACK_OK,
 296                 resource->observe(ObserveType::ObserveAll, query, &onObserve,
 297                         QualityOfService::NaQos));
 298     }
 299
 300     TEST(ResourceObserveTest, ResourceObserveMidQos)
 301     {
 302         QueryParamsMap query = {};
 303         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/Observe");
 304         EXPECT_TRUE(resource != NULL);
 305         EXPECT_EQ(OC_STACK_OK,
 306                 resource->observe(ObserveType::ObserveAll, query, &onObserve,
 307                         QualityOfService::MidQos));
 308     }
 309
 310     //Enable it when CON is supported in the stack.
 311     TEST(ResourceObserveTest, DISABLED_ResourceObserveHighQos)
 312     {
 313         QueryParamsMap query = {};
 314         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/Observe");
 315         EXPECT_TRUE(resource != NULL);
 316         EXPECT_EQ(OC_STACK_OK,
 317                 resource->observe(ObserveType::ObserveAll, query, &onObserve,
 318                         QualityOfService::HighQos));
 319     }
 320
 321     TEST(ResourceObserveTest, ResourceCancelObserveValidUri)
 322     {
 323         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 324         EXPECT_TRUE(resource != NULL);
 325         QueryParamsMap query = {};
 326         EXPECT_EQ(OC_STACK_OK, resource->observe(ObserveType::ObserveAll, query, &onObserve));
 327         EXPECT_EQ(OC_STACK_OK, resource->cancelObserve());
 328     }
 329
 330     TEST(ResourceObserveTest, ResourceCancelObserveWithNaQos)
 331     {
 332         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 333         EXPECT_TRUE(resource != NULL);
 334         QueryParamsMap query = {};
 335         EXPECT_EQ(OC_STACK_OK,
 336                 resource->observe(ObserveType::ObserveAll, query, &onObserve,
 337                         QualityOfService::NaQos));
 338         EXPECT_EQ(OC_STACK_OK, resource->cancelObserve(QualityOfService::NaQos));
 339     }
 340
 341     TEST(ResourceObserveTest, ResourceCancelObserveWithLowQos)
 342     {
 343         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 344         EXPECT_TRUE(resource != NULL);
 345         QueryParamsMap query = {};
 346         EXPECT_EQ(OC_STACK_OK,
 347                 resource->observe(ObserveType::ObserveAll, query, &onObserve,
 348                         QualityOfService::LowQos));
 349         EXPECT_EQ(OC_STACK_OK, resource->cancelObserve(QualityOfService::LowQos));
 350     }
 351
 352     TEST(ResourceObserveTest, ResourceCancelObserveWithMidQos)
 353     {
 354         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 355         EXPECT_TRUE(resource != NULL);
 356             QueryParamsMap query = {};
 357         EXPECT_EQ(OC_STACK_OK,
 358                 resource->observe(ObserveType::ObserveAll, query, &onObserve,
 359                         QualityOfService::MidQos));
 360         EXPECT_EQ(OC_STACK_OK, resource->cancelObserve(QualityOfService::MidQos));
 361     }
 362
 363     // We enable it when the CON is supported in the stack.
 364     TEST(ResourceObserveTest, DISABLED_ResourceCancelObserveWithHighQos)
 365     {
 366         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 367         EXPECT_TRUE(resource != NULL);
 368             QueryParamsMap query = {};
 369         EXPECT_EQ(OC_STACK_OK,
 370                 resource->observe(ObserveType::ObserveAll, query, &onObserve,
 371                         QualityOfService::HighQos));
 372         EXPECT_EQ(OC_STACK_OK, resource->cancelObserve(QualityOfService::HighQos));
 373     }
 374
 375     //DeleteResource
 376     TEST(DeleteResourceTest, DeleteResourceValidUri)
 377     {
 378         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 379         EXPECT_TRUE(resource != NULL);
 380         EXPECT_EQ(OC_STACK_OK, resource->deleteResource(&deleteResponse));
 381     }
 382
 383     TEST(DeleteResourceTest, DeleteResourceWithLowQos)
 384     {
 385         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 386         EXPECT_TRUE(resource != NULL);
 387         EXPECT_EQ(OC_STACK_OK,
 388                 resource->deleteResource(&deleteResponse, QualityOfService::LowQos));
 389     }
 390
 391     TEST(DeleteResourceTest, DeleteResourceWithMidQos)
 392     {
 393         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 394         EXPECT_TRUE(resource != NULL);
 395         EXPECT_EQ(OC_STACK_OK,
 396                 resource->deleteResource(&deleteResponse, QualityOfService::MidQos));
 397     }
 398
 399     TEST(DeleteResourceTest, DeleteResourceWithHighQos)
 400     {
 401         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 402         EXPECT_TRUE(resource != NULL);
 403         EXPECT_EQ(OC_STACK_OK,
 404                 resource->deleteResource(&deleteResponse, QualityOfService::HighQos));
 405     }
 406     TEST(DeleteResourceTest, DeleteResourceWithNaQos)
 407     {
 408         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 409         EXPECT_TRUE(resource != NULL);
 410         EXPECT_EQ(OC_STACK_OK, resource->deleteResource(&deleteResponse, QualityOfService::NaQos));
 411     }
 412
 413     //GetResourceInterfaces Test
 414     TEST(GetResourceInterfacesTest, GetResourceInterfaces)
 415     {
 416         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 417         EXPECT_TRUE(resource != NULL);
 418         EXPECT_TRUE(resource->getResourceInterfaces().front() == DEFAULT_INTERFACE);
 419     }
 420
 421     //GetResourceTypes Test
 422     TEST(GetResourceTypesTest, GetResourceTypes)
 423     {
 424         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 425         EXPECT_TRUE(resource != NULL);
 426         EXPECT_TRUE(resource->getResourceTypes().front() == "intel.rpost");
 427     }
 428
 429     // Host Test
 430     TEST(HostTest, Host)
 431     {
 432         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 433         EXPECT_TRUE(resource != NULL);
 434         EXPECT_TRUE(resource->host() == "coap://192.168.1.2:5000");
 435     }
 436
 437     //Uri Test
 438     TEST(UriTest, Uri)
 439     {
 440         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 441         EXPECT_TRUE(resource != NULL);
 442         EXPECT_TRUE(resource->uri() == "/resource");
 443     }
 444
 445     //ConnectivityType Test
 446     TEST(ConnectivityTypeTest, ConnectivityType)
 447     {
 448         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 449         EXPECT_TRUE(resource != NULL);
 450         EXPECT_TRUE(resource->connectivityType() == OC_WIFI);
 451     }
 452
 453     //IsObservable Test
 454     TEST(IsObservableTest, isObservable)
 455     {
 456         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 457         EXPECT_TRUE(resource != NULL);
 458         EXPECT_FALSE(resource->isObservable());
 459     }
 460
 461     //SID Test
 462     TEST(SidTest, sid)
 463     {
 464         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 465         EXPECT_TRUE(resource != NULL);
 466         EXPECT_TRUE(resource->sid() == "0");
 467     }
 468
 469     //UniqueIdentifier Test
 470     TEST(UniqueIdentifierTest, uniqueIdentifier)
 471     {
 472         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 473         EXPECT_TRUE(resource != NULL);
 474         std::ostringstream ss;
 475         ss << resource->uniqueIdentifier();
 476         EXPECT_TRUE(ss.str() == "0/resource");
 477     }
 478
 479     // HeaderOptions Test
 480     TEST(HeaderOptionsTest, SetHeaderOptionsValidInput)
 481     {
 482         const uint16_t API_VERSION = 2048;
 483         const uint16_t TOKEN = 3000;
 484         HeaderOptions headerOptions;
 485         HeaderOption::OCHeaderOption apiVersion(API_VERSION, "v.1.0");
 486         HeaderOption::OCHeaderOption clientToken(TOKEN, "21ae43gf");
 487         headerOptions.push_back(apiVersion);
 488         headerOptions.push_back(clientToken);
 489
 490         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 491         EXPECT_TRUE(resource != NULL);
 492         EXPECT_NO_THROW(resource->setHeaderOptions(headerOptions));
 493         EXPECT_NO_THROW(resource->unsetHeaderOptions());
 494     }
 495
 496     TEST(HeaderOptionsTest, SetHeaderOptionsEmptyInput)
 497     {
 498         OCResource::Ptr resource = ConstructResourceObject("coap://192.168.1.2:5000", "/resource");
 499         EXPECT_TRUE(resource != NULL);
 500         HeaderOptions headerOptions = {};
 501         EXPECT_NO_THROW(resource->setHeaderOptions(headerOptions));
 502         EXPECT_NO_THROW(resource->unsetHeaderOptions());
 503     }
 504 }
 505