radio/1.0/vts/functional/radio_hidl_hal_sms.cpp

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <radio_hidl_hal_utils.h>
  18
  19 using namespace ::android::hardware::radio::V1_0;
  20
  21 /*
  22  * Test IRadio.sendSms() for the response returned.
  23  */
  24 TEST_F(RadioHidlTest, sendSms) {
  25     int serial = GetRandomSerialNumber();
  26     GsmSmsMessage msg;
  27     msg.smscPdu = "";
  28     msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
  29
  30     radio->sendSms(serial, msg);
  31
  32     EXPECT_EQ(std::cv_status::no_timeout, wait());
  33     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
  34     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
  35
  36     if (cardStatus.cardState == CardState::ABSENT) {
  37         ASSERT_TRUE(CheckGeneralError() ||
  38                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
  39                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
  40                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
  41         EXPECT_EQ(0, radioRsp->sendSmsResult.errorCode);
  42     }
  43 }
  44
  45 /*
  46  * Test IRadio.sendSMSExpectMore() for the response returned.
  47  */
  48 TEST_F(RadioHidlTest, sendSMSExpectMore) {
  49     int serial = GetRandomSerialNumber();
  50     GsmSmsMessage msg;
  51     msg.smscPdu = "";
  52     msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
  53
  54     radio->sendSMSExpectMore(serial, msg);
  55
  56     // TODO(shuoq): add more test for this API when inserted sim card is
  57     // considered
  58
  59     EXPECT_EQ(std::cv_status::no_timeout, wait());
  60     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
  61     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
  62
  63     if (cardStatus.cardState == CardState::ABSENT) {
  64         ASSERT_TRUE(CheckGeneralError() ||
  65                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
  66                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
  67                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
  68     }
  69 }
  70
  71 /*
  72  * Test IRadio.acknowledgeLastIncomingGsmSms() for the response returned.
  73  */
  74 TEST_F(RadioHidlTest, acknowledgeLastIncomingGsmSms) {
  75     int serial = GetRandomSerialNumber();
  76     bool success = true;
  77
  78     radio->acknowledgeLastIncomingGsmSms(serial, success,
  79                                          SmsAcknowledgeFailCause::MEMORY_CAPACITY_EXCEEDED);
  80
  81     EXPECT_EQ(std::cv_status::no_timeout, wait());
  82     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
  83     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
  84
  85     if (cardStatus.cardState == CardState::ABSENT) {
  86         ASSERT_TRUE(CheckGeneralError() ||
  87                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
  88                     radioRsp->rspInfo.error == RadioError::INVALID_STATE);
  89     }
  90 }
  91
  92 /*
  93  * Test IRadio.acknowledgeIncomingGsmSmsWithPdu() for the response returned.
  94  */
  95 TEST_F(RadioHidlTest, acknowledgeIncomingGsmSmsWithPdu) {
  96     int serial = GetRandomSerialNumber();
  97     bool success = true;
  98     std::string ackPdu = "";
  99
 100     radio->acknowledgeIncomingGsmSmsWithPdu(serial, success, ackPdu);
 101
 102     EXPECT_EQ(std::cv_status::no_timeout, wait());
 103     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 104     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 105
 106     if (cardStatus.cardState == CardState::ABSENT) {
 107         // TODO(shuoq): Will add error check when we know the expected error from QC
 108     }
 109 }
 110
 111 /*
 112  * Test IRadio.sendCdmaSms() for the response returned.
 113  */
 114 TEST_F(RadioHidlTest, sendCdmaSms) {
 115     int serial = GetRandomSerialNumber();
 116
 117     // Create a CdmaSmsAddress
 118     CdmaSmsAddress cdmaSmsAddress;
 119     cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
 120     cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
 121     cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
 122     cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
 123     cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
 124
 125     // Create a CdmaSmsSubAddress
 126     CdmaSmsSubaddress cdmaSmsSubaddress;
 127     cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
 128     cdmaSmsSubaddress.odd = false;
 129     cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
 130
 131     // Create a CdmaSmsMessage
 132     android::hardware::radio::V1_0::CdmaSmsMessage cdmaSmsMessage;
 133     cdmaSmsMessage.teleserviceId = 4098;
 134     cdmaSmsMessage.isServicePresent = false;
 135     cdmaSmsMessage.serviceCategory = 0;
 136     cdmaSmsMessage.address = cdmaSmsAddress;
 137     cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
 138     cdmaSmsMessage.bearerData =
 139         (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
 140
 141     radio->sendCdmaSms(serial, cdmaSmsMessage);
 142
 143     EXPECT_EQ(std::cv_status::no_timeout, wait());
 144     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 145     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 146
 147     if (cardStatus.cardState == CardState::ABSENT) {
 148         ASSERT_TRUE(CheckGeneralError() ||
 149                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 150                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 151                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 152     }
 153 }
 154
 155 /*
 156  * Test IRadio.acknowledgeLastIncomingCdmaSms() for the response returned.
 157  */
 158 TEST_F(RadioHidlTest, acknowledgeLastIncomingCdmaSms) {
 159     int serial = GetRandomSerialNumber();
 160
 161     // Create a CdmaSmsAck
 162     CdmaSmsAck cdmaSmsAck;
 163     cdmaSmsAck.errorClass = CdmaSmsErrorClass::NO_ERROR;
 164     cdmaSmsAck.smsCauseCode = 1;
 165
 166     radio->acknowledgeLastIncomingCdmaSms(serial, cdmaSmsAck);
 167
 168     EXPECT_EQ(std::cv_status::no_timeout, wait());
 169     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 170     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 171
 172     if (cardStatus.cardState == CardState::ABSENT) {
 173         ASSERT_TRUE(CheckGeneralError() ||
 174                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 175                     radioRsp->rspInfo.error == RadioError::NO_SMS_TO_ACK);
 176     }
 177 }
 178
 179 /*
 180  * Test IRadio.sendImsSms() for the response returned.
 181  */
 182 TEST_F(RadioHidlTest, sendImsSms) {
 183     int serial = GetRandomSerialNumber();
 184
 185     // Create a CdmaSmsAddress
 186     CdmaSmsAddress cdmaSmsAddress;
 187     cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
 188     cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
 189     cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
 190     cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
 191     cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
 192
 193     // Create a CdmaSmsSubAddress
 194     CdmaSmsSubaddress cdmaSmsSubaddress;
 195     cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
 196     cdmaSmsSubaddress.odd = false;
 197     cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
 198
 199     // Create a CdmaSmsMessage
 200     CdmaSmsMessage cdmaSmsMessage;
 201     cdmaSmsMessage.teleserviceId = 4098;
 202     cdmaSmsMessage.isServicePresent = false;
 203     cdmaSmsMessage.serviceCategory = 0;
 204     cdmaSmsMessage.address = cdmaSmsAddress;
 205     cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
 206     cdmaSmsMessage.bearerData =
 207         (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
 208
 209     // Creata an ImsSmsMessage
 210     ImsSmsMessage msg;
 211     msg.tech = RadioTechnologyFamily::THREE_GPP2;
 212     msg.retry = false;
 213     msg.messageRef = 0;
 214     msg.cdmaMessage = (std::vector<CdmaSmsMessage>){cdmaSmsMessage};
 215     msg.gsmMessage = (std::vector<GsmSmsMessage>){};
 216
 217     radio->sendImsSms(serial, msg);
 218
 219     EXPECT_EQ(std::cv_status::no_timeout, wait());
 220     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 221     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 222
 223     if (cardStatus.cardState == CardState::ABSENT) {
 224         ASSERT_TRUE(CheckGeneralError() ||
 225                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS);
 226     }
 227 }
 228
 229 /*
 230  * Test IRadio.getSmscAddress() for the response returned.
 231  */
 232 TEST_F(RadioHidlTest, getSmscAddress) {
 233     int serial = GetRandomSerialNumber();
 234
 235     radio->getSmscAddress(serial);
 236
 237     EXPECT_EQ(std::cv_status::no_timeout, wait());
 238     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 239     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 240
 241     if (cardStatus.cardState == CardState::ABSENT) {
 242         ASSERT_TRUE(CheckGeneralError() ||
 243                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 244                     radioRsp->rspInfo.error ==
 245                         RadioError::INVALID_MODEM_STATE ||
 246                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 247     }
 248 }
 249
 250 /*
 251  * Test IRadio.setSmscAddress() for the response returned.
 252  */
 253 TEST_F(RadioHidlTest, setSmscAddress) {
 254     int serial = GetRandomSerialNumber();
 255     hidl_string address = hidl_string("smscAddress");
 256
 257     radio->setSmscAddress(serial, address);
 258
 259     EXPECT_EQ(std::cv_status::no_timeout, wait());
 260     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 261     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 262
 263     if (cardStatus.cardState == CardState::ABSENT) {
 264         ASSERT_TRUE(CheckGeneralError() ||
 265                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 266                     radioRsp->rspInfo.error == RadioError::INVALID_SMS_FORMAT ||
 267                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 268     }
 269 }
 270
 271 /*
 272  * Test IRadio.writeSmsToSim() for the response returned.
 273  */
 274 TEST_F(RadioHidlTest, writeSmsToSim) {
 275     int serial = GetRandomSerialNumber();
 276     SmsWriteArgs smsWriteArgs;
 277     smsWriteArgs.status = SmsWriteArgsStatus::REC_UNREAD;
 278     smsWriteArgs.smsc = "";
 279     smsWriteArgs.pdu = "01000b916105770203f3000006d4f29c3e9b01";
 280
 281     radio->writeSmsToSim(serial, smsWriteArgs);
 282
 283     EXPECT_EQ(std::cv_status::no_timeout, wait());
 284     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 285     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 286
 287     if (cardStatus.cardState == CardState::ABSENT) {
 288         ASSERT_TRUE(CheckGeneralError() ||
 289                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 290                     radioRsp->rspInfo.error == RadioError::NONE ||
 291                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
 292                     radioRsp->rspInfo.error == RadioError::ENCODING_ERR ||
 293                     radioRsp->rspInfo.error == RadioError::NO_RESOURCES ||
 294                     radioRsp->rspInfo.error == RadioError::NETWORK_NOT_READY ||
 295                     radioRsp->rspInfo.error ==
 296                         RadioError::INVALID_SMSC_ADDRESS ||
 297                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 298     }
 299 }
 300
 301 /*
 302  * Test IRadio.deleteSmsOnSim() for the response returned.
 303  */
 304 TEST_F(RadioHidlTest, deleteSmsOnSim) {
 305     int serial = GetRandomSerialNumber();
 306     int index = 1;
 307
 308     radio->deleteSmsOnSim(serial, index);
 309
 310     EXPECT_EQ(std::cv_status::no_timeout, wait());
 311     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 312     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 313
 314     if (cardStatus.cardState == CardState::ABSENT) {
 315         ASSERT_TRUE(CheckGeneralError() ||
 316                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 317                     radioRsp->rspInfo.error == RadioError::NONE ||
 318                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
 319                     radioRsp->rspInfo.error == RadioError::NO_SUCH_ENTRY ||
 320                     radioRsp->rspInfo.error ==
 321                         RadioError::INVALID_MODEM_STATE ||
 322                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 323     }
 324 }
 325
 326 /*
 327  * Test IRadio.writeSmsToRuim() for the response returned.
 328  */
 329 TEST_F(RadioHidlTest, writeSmsToRuim) {
 330     int serial = GetRandomSerialNumber();
 331
 332     // Create a CdmaSmsAddress
 333     CdmaSmsAddress cdmaSmsAddress;
 334     cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
 335     cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
 336     cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
 337     cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
 338     cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
 339
 340     // Create a CdmaSmsSubAddress
 341     CdmaSmsSubaddress cdmaSmsSubaddress;
 342     cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
 343     cdmaSmsSubaddress.odd = false;
 344     cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
 345
 346     // Create a CdmaSmsMessage
 347     CdmaSmsMessage cdmaSmsMessage;
 348     cdmaSmsMessage.teleserviceId = 4098;
 349     cdmaSmsMessage.isServicePresent = false;
 350     cdmaSmsMessage.serviceCategory = 0;
 351     cdmaSmsMessage.address = cdmaSmsAddress;
 352     cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
 353     cdmaSmsMessage.bearerData =
 354         (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
 355
 356     // Create a CdmaSmsWriteArgs
 357     CdmaSmsWriteArgs cdmaSmsWriteArgs;
 358     cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
 359     cdmaSmsWriteArgs.message = cdmaSmsMessage;
 360
 361     radio->writeSmsToRuim(serial, cdmaSmsWriteArgs);
 362
 363     EXPECT_EQ(std::cv_status::no_timeout, wait());
 364     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 365     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 366
 367     if (cardStatus.cardState == CardState::ABSENT) {
 368         ASSERT_TRUE(CheckGeneralError() ||
 369                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 370                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 371                     radioRsp->rspInfo.error == RadioError::INVALID_SMS_FORMAT ||
 372                     radioRsp->rspInfo.error == RadioError::NONE ||
 373                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
 374                     radioRsp->rspInfo.error == RadioError::NO_SUCH_ENTRY ||
 375                     radioRsp->rspInfo.error ==
 376                         RadioError::INVALID_SMSC_ADDRESS ||
 377                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 378     }
 379 }
 380
 381 /*
 382  * Test IRadio.deleteSmsOnRuim() for the response returned.
 383  */
 384 TEST_F(RadioHidlTest, deleteSmsOnRuim) {
 385     int serial = GetRandomSerialNumber();
 386     int index = 1;
 387
 388     // Create a CdmaSmsAddress
 389     CdmaSmsAddress cdmaSmsAddress;
 390     cdmaSmsAddress.digitMode = CdmaSmsDigitMode::FOUR_BIT;
 391     cdmaSmsAddress.numberMode = CdmaSmsNumberMode::NOT_DATA_NETWORK;
 392     cdmaSmsAddress.numberType = CdmaSmsNumberType::UNKNOWN;
 393     cdmaSmsAddress.numberPlan = CdmaSmsNumberPlan::UNKNOWN;
 394     cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
 395
 396     // Create a CdmaSmsSubAddress
 397     CdmaSmsSubaddress cdmaSmsSubaddress;
 398     cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddressType::NSAP;
 399     cdmaSmsSubaddress.odd = false;
 400     cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
 401
 402     // Create a CdmaSmsMessage
 403     CdmaSmsMessage cdmaSmsMessage;
 404     cdmaSmsMessage.teleserviceId = 4098;
 405     cdmaSmsMessage.isServicePresent = false;
 406     cdmaSmsMessage.serviceCategory = 0;
 407     cdmaSmsMessage.address = cdmaSmsAddress;
 408     cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
 409     cdmaSmsMessage.bearerData =
 410         (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
 411
 412     // Create a CdmaSmsWriteArgs
 413     CdmaSmsWriteArgs cdmaSmsWriteArgs;
 414     cdmaSmsWriteArgs.status = CdmaSmsWriteArgsStatus::REC_UNREAD;
 415     cdmaSmsWriteArgs.message = cdmaSmsMessage;
 416
 417     radio->deleteSmsOnRuim(serial, index);
 418
 419     EXPECT_EQ(std::cv_status::no_timeout, wait());
 420     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 421     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 422
 423     if (cardStatus.cardState == CardState::ABSENT) {
 424         ASSERT_TRUE(CheckGeneralError() ||
 425                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 426                     radioRsp->rspInfo.error == RadioError::NONE ||
 427                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
 428                     radioRsp->rspInfo.error == RadioError::NO_SUCH_ENTRY ||
 429                     radioRsp->rspInfo.error ==
 430                         RadioError::INVALID_MODEM_STATE ||
 431                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 432     }
 433 }
 434
 435 /*
 436  * Test IRadio.reportSmsMemoryStatus() for the response returned.
 437  */
 438 TEST_F(RadioHidlTest, reportSmsMemoryStatus) {
 439     int serial = GetRandomSerialNumber();
 440     bool available = true;
 441
 442     radio->reportSmsMemoryStatus(serial, available);
 443
 444     EXPECT_EQ(std::cv_status::no_timeout, wait());
 445     EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp->rspInfo.type);
 446     EXPECT_EQ(serial, radioRsp->rspInfo.serial);
 447
 448     if (cardStatus.cardState == CardState::ABSENT) {
 449         ASSERT_TRUE(CheckGeneralError() ||
 450                     radioRsp->rspInfo.error == RadioError::INVALID_ARGUMENTS ||
 451                     radioRsp->rspInfo.error == RadioError::INVALID_STATE ||
 452                     radioRsp->rspInfo.error == RadioError::MODEM_ERR ||
 453                     radioRsp->rspInfo.error == RadioError::SIM_ABSENT);
 454     }
 455 }