[Summary view]

Differences Between: [Versions 310 and 400] [Versions 39 and 400]

   1  <?php
   2  // This file is part of Moodle - http://moodle.org/
   3  //
   4  // Moodle is free software: you can redistribute it and/or modify
   5  // it under the terms of the GNU General Public License as published by
   6  // the Free Software Foundation, either version 3 of the License, or
   7  // (at your option) any later version.
   8  //
   9  // Moodle is distributed in the hope that it will be useful,
  10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  // GNU General Public License for more details.
  13  //
  14  // You should have received a copy of the GNU General Public License
  15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16  
  17  /**
  18   * Tests for core_message_inbound to test Variable Envelope Return Path functionality.
  19   *
  20   * @package    core_message
  21   * @copyright  2014 Andrew Nicols <andrew@nicols.co.uk>
  22   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  namespace core_message;
  26  
  27  defined('MOODLE_INTERNAL') || die();
  28  require_once (__DIR__ . '/fixtures/inbound_fixtures.php');
  29  
  30  /**
  31   * Tests for core_message_inbound to test Variable Envelope Return Path functionality.
  32   *
  33   * @package    core_message
  34   * @copyright  2014 Andrew Nicols <andrew@nicols.co.uk>
  35   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  36   */
  37  class inbound_test extends \advanced_testcase {
  38  
  39      /**
  40       * Perform setup tasks generic to each test.
  41       * This includes:
  42       * * configuring the messageinbound_mailbox.
  43       */
  44      public function setUp(): void {
  45          global $CFG;
  46  
  47          $this->resetAfterTest(true);
  48  
  49          // Setup the default Inbound Message mailbox settings.
  50          $CFG->messageinbound_domain = 'example.com';
  51          $CFG->messageinbound_enabled = true;
  52  
  53          // Must be no longer than 15 characters.
  54          $CFG->messageinbound_mailbox = 'moodlemoodle123';
  55      }
  56  
  57      /**
  58       * Helper to create a new Inbound Message handler.
  59       *
  60       * @param $handlerclass The class of the handler to create
  61       * @param $enabled Whether the handler should be enabled
  62       * @param $component The component
  63       * @param $namepace The namepace
  64       */
  65      public function helper_create_handler($handlerclass, $enabled = true, $component = 'core_test', $namespace = '\\core\\test\\') {
  66          global $DB;
  67  
  68          $classname = $namespace . $handlerclass;
  69          $record = \core\message\inbound\manager::record_from_handler(new $classname());
  70          $record->component = $component;
  71          $record->enabled = $enabled;
  72          $record->id = $DB->insert_record('messageinbound_handlers', $record);
  73          $handler = core_message_inbound_test_manager::handler_from_record($record);
  74  
  75          return $handler;
  76      }
  77  
  78      /**
  79       * Test that the enabled check perform as expected.
  80       */
  81      public function test_is_enabled() {
  82          global $CFG;
  83  
  84          // First clear all of the settings set in the setUp.
  85          $CFG->messageinbound_domain = null;
  86          $CFG->messageinbound_enabled = null;
  87          $CFG->messageinbound_mailbox = null;
  88  
  89          $this->assertFalse(\core\message\inbound\manager::is_enabled());
  90  
  91          // Check whether only setting the enabled flag keeps it disabled.
  92          $CFG->messageinbound_enabled = true;
  93          $this->assertFalse(\core\message\inbound\manager::is_enabled());
  94  
  95          // Check that the mailbox entry on it's own does not enable Inbound Message handling.
  96          $CFG->messageinbound_mailbox = 'moodlemoodle123';
  97          $CFG->messageinbound_domain = null;
  98          $this->assertFalse(\core\message\inbound\manager::is_enabled());
  99  
 100          // And that the domain on it's own does not.
 101          $CFG->messageinbound_domain = 'example.com';
 102          $CFG->messageinbound_mailbox = null;
 103          $this->assertFalse(\core\message\inbound\manager::is_enabled());
 104  
 105          // And that an invalid mailbox does not.
 106          $CFG->messageinbound_mailbox = '';
 107          $CFG->messageinbound_domain = 'example.com';
 108          $this->assertFalse(\core\message\inbound\manager::is_enabled());
 109  
 110          // And that an invalid domain does not.
 111          $CFG->messageinbound_domain = '';
 112          $CFG->messageinbound_mailbox = 'moodlemoodle123';
 113          $this->assertFalse(\core\message\inbound\manager::is_enabled());
 114  
 115          // Finally a test that ensures that all settings correct enables the system.
 116          $CFG->messageinbound_mailbox = 'moodlemoodle123';
 117          $CFG->messageinbound_domain = 'example.com';
 118          $CFG->messageinbound_enabled = true;
 119  
 120          $this->assertTrue(\core\message\inbound\manager::is_enabled());
 121      }
 122  
 123      /**
 124       * Test that data items conform to RFCs 5231, and 5322 standards for
 125       * addressing, and to RFC 5233 for sub-addressing.
 126       */
 127      public function test_address_constraints() {
 128          $handler = $this->helper_create_handler('handler_one');
 129  
 130          // Using the handler created, generate an address for our data entry.
 131          $processor = new core_message_inbound_test_helper();
 132          $processor->set_handler($handler->classname);
 133  
 134          // Generate some IDs for the data and generate addresses for them.
 135          $dataids = array(
 136              -1,
 137              0,
 138              42,
 139              1073741823,
 140              2147483647,
 141          );
 142  
 143          $user = $this->getDataGenerator()->create_user();
 144          foreach ($dataids as $dataid) {
 145              $processor->set_data($dataid);
 146              $address = $processor->generate($user->id);
 147              $this->assertNotNull($address);
 148              $this->assertTrue(strlen($address) > 0, 'No address generated.');
 149              $this->assertTrue(strpos($address, '@') !== false, 'No domain found.');
 150              $this->assertTrue(strpos($address, '+') !== false, 'No subaddress found.');
 151  
 152              // The localpart must be less than 64 characters.
 153              list($localpart) = explode('@', $address);
 154              $this->assertTrue(strlen($localpart) <= 64, 'Localpart section of address too long');
 155  
 156              // And the data section should be no more than 48 characters.
 157              list(, $datasection) = explode('+', $localpart);
 158              $this->assertTrue(strlen($datasection) <= 48, 'Data section of address too long');
 159          }
 160      }
 161  
 162      /**
 163       * Test that the generated e-mail addresses are sufficiently random by
 164       * testing the multiple handlers, multiple users, and multiple data
 165       * items.
 166       */
 167      public function test_address_uniqueness() {
 168          // Generate a set of handlers. These are in two components, and each
 169          // component has two different generators.
 170          $handlers = array();
 171          $handlers[] = $this->helper_create_handler('handler_one', true, 'core_test');
 172          $handlers[] = $this->helper_create_handler('handler_two', true, 'core_test');
 173          $handlers[] = $this->helper_create_handler('handler_three', true, 'core_test_example');
 174          $handlers[] = $this->helper_create_handler('handler_four', true, 'core_test_example');
 175  
 176          // Generate some IDs for the data and generate addresses for them.
 177          $dataids = array(
 178              0,
 179              42,
 180              1073741823,
 181              2147483647,
 182          );
 183  
 184          $users = array();
 185          for ($i = 0; $i < 5; $i++) {
 186              $users[] = $this->getDataGenerator()->create_user();
 187          }
 188  
 189          // Store the addresses for later comparison.
 190          $addresses = array();
 191  
 192          foreach ($handlers as $handler) {
 193              $processor = new core_message_inbound_test_helper();
 194              $processor->set_handler($handler->classname);
 195  
 196              // Check each dataid.
 197              foreach ($dataids as $dataid) {
 198                  $processor->set_data($dataid);
 199  
 200                  // Check each user.
 201                  foreach ($users as $user) {
 202                      $address = $processor->generate($user->id);
 203                      $this->assertFalse(isset($addresses[$address]));
 204                      $addresses[$address] = true;
 205                  }
 206              }
 207          }
 208      }
 209  
 210      /**
 211       * Test address parsing of a generated address.
 212       */
 213      public function test_address_parsing() {
 214          $dataid = 42;
 215  
 216          // Generate a handler to use for this set of tests.
 217          $handler = $this->helper_create_handler('handler_one');
 218  
 219          // And a user.
 220          $user = $this->getDataGenerator()->create_user();
 221  
 222          // Using the handler created, generate an address for our data entry.
 223          $processor = new core_message_inbound_test_helper();
 224          $processor->set_handler($handler->classname);
 225          $processor->set_data($dataid);
 226          $address = $processor->generate($user->id);
 227  
 228          // We should be able to parse the address.
 229          $parser = new core_message_inbound_test_helper();
 230          $parser->process($address);
 231          $parsedresult = $parser->get_data();
 232          $this->assertEquals($user->id, $parsedresult->userid);
 233          $this->assertEquals($dataid, $parsedresult->datavalue);
 234          $this->assertEquals($dataid, $parsedresult->data->datavalue);
 235          $this->assertEquals($handler->id, $parsedresult->handlerid);
 236          $this->assertEquals($handler->id, $parsedresult->data->handler);
 237      }
 238  
 239      /**
 240       * Test address parsing of an address with an unrecognised format.
 241       */
 242      public function test_address_validation_invalid_format_failure() {
 243          // Create test data.
 244          $user = $this->getDataGenerator()->create_user();
 245          $handler = $this->helper_create_handler('handler_one');
 246          $dataid = 42;
 247  
 248          $parser = new core_message_inbound_test_helper();
 249  
 250          $generator = new core_message_inbound_test_helper();
 251          $generator->set_handler($handler->classname);
 252  
 253          // Check that validation fails when no address has been processed.
 254          $result = $parser->validate($user->email);
 255          $this->assertEquals(\core\message\inbound\address_manager::VALIDATION_INVALID_ADDRESS_FORMAT, $result);
 256  
 257          // Test that an address without data fails validation.
 258          $parser->process('bob@example.com');
 259          $result = $parser->validate($user->email);
 260          $this->assertEquals(\core\message\inbound\address_manager::VALIDATION_INVALID_ADDRESS_FORMAT, $result);
 261  
 262          // Test than address with a subaddress but invalid data fails with VALIDATION_UNKNOWN_DATAKEY.
 263          $parser->process('bob+nodata@example.com');
 264          $result = $parser->validate($user->email);
 265          $this->assertEquals(\core\message\inbound\address_manager::VALIDATION_INVALID_ADDRESS_FORMAT, $result);
 266      }
 267  
 268      /**
 269       * Test address parsing of an address with an unknown handler.
 270       */
 271      public function test_address_validation_unknown_handler() {
 272          global $DB;
 273  
 274          // Create test data.
 275          $user = $this->getDataGenerator()->create_user();
 276          $handler = $this->helper_create_handler('handler_one');
 277          $dataid = 42;
 278  
 279          $parser = new core_message_inbound_test_helper();
 280  
 281          $generator = new core_message_inbound_test_helper();
 282          $generator->set_handler($handler->classname);
 283          $generator->set_data($dataid);
 284          $address = $generator->generate($user->id);
 285  
 286          // Remove the handler record to invalidate it.
 287          $DB->delete_records('messageinbound_handlers', array(
 288              'id' => $handler->id,
 289          ));
 290  
 291          $parser->process($address);
 292          $result = $parser->validate($user->email);
 293          $expectedfail = \core\message\inbound\address_manager::VALIDATION_UNKNOWN_HANDLER;
 294          $this->assertEquals($expectedfail, $result & $expectedfail);
 295      }
 296  
 297      /**
 298       * Test address parsing of an address with a disabled handler.
 299       */
 300      public function test_address_validation_disabled_handler() {
 301          global $DB;
 302  
 303          // Create test data.
 304          $user = $this->getDataGenerator()->create_user();
 305          $handler = $this->helper_create_handler('handler_one');
 306          $dataid = 42;
 307  
 308          $parser = new core_message_inbound_test_helper();
 309  
 310          $generator = new core_message_inbound_test_helper();
 311          $generator->set_handler($handler->classname);
 312          $generator->set_data($dataid);
 313          $address = $generator->generate($user->id);
 314  
 315          // Disable the handler.
 316          $record = \core\message\inbound\manager::record_from_handler($handler);
 317          $record->enabled = false;
 318          $DB->update_record('messageinbound_handlers', $record);
 319  
 320          $parser->process($address);
 321          $result = $parser->validate($user->email);
 322          $expectedfail = \core\message\inbound\address_manager::VALIDATION_DISABLED_HANDLER;
 323          $this->assertEquals($expectedfail, $result & $expectedfail);
 324      }
 325  
 326      /**
 327       * Test address parsing of an address for an invalid user.
 328       */
 329      public function test_address_validation_invalid_user() {
 330          global $DB;
 331  
 332          // Create test data.
 333          $user = $this->getDataGenerator()->create_user();
 334          $handler = $this->helper_create_handler('handler_one');
 335          $dataid = 42;
 336  
 337          $parser = new core_message_inbound_test_helper();
 338  
 339          $generator = new core_message_inbound_test_helper();
 340          $generator->set_handler($handler->classname);
 341          $generator->set_data($dataid);
 342          $address = $generator->generate(-1);
 343  
 344          $parser->process($address);
 345          $result = $parser->validate($user->email);
 346          $expectedfail = \core\message\inbound\address_manager::VALIDATION_UNKNOWN_USER;
 347          $this->assertEquals($expectedfail, $result & $expectedfail);
 348      }
 349  
 350      /**
 351       * Test address parsing of an address for a disabled user.
 352       */
 353      public function test_address_validation_disabled_user() {
 354          global $DB;
 355  
 356          // Create test data.
 357          $user = $this->getDataGenerator()->create_user();
 358          $handler = $this->helper_create_handler('handler_one');
 359          $dataid = 42;
 360  
 361          $parser = new core_message_inbound_test_helper();
 362  
 363          $generator = new core_message_inbound_test_helper();
 364          $generator->set_handler($handler->classname);
 365          $generator->set_data($dataid);
 366          $address = $generator->generate($user->id);
 367  
 368          // Unconfirm the user.
 369          $user->confirmed = 0;
 370          $DB->update_record('user', $user);
 371  
 372          $parser->process($address);
 373          $result = $parser->validate($user->email);
 374          $expectedfail = \core\message\inbound\address_manager::VALIDATION_DISABLED_USER;
 375          $this->assertEquals($expectedfail, $result & $expectedfail);
 376      }
 377  
 378      /**
 379       * Test address parsing of an address for an invalid key.
 380       */
 381      public function test_address_validation_invalid_key() {
 382          global $DB;
 383  
 384          // Create test data.
 385          $user = $this->getDataGenerator()->create_user();
 386          $handler = $this->helper_create_handler('handler_one');
 387          $dataid = 42;
 388  
 389          $parser = new core_message_inbound_test_helper();
 390  
 391          $generator = new core_message_inbound_test_helper();
 392          $generator->set_handler($handler->classname);
 393          $generator->set_data($dataid);
 394          $address = $generator->generate($user->id);
 395  
 396          // Remove the data record to invalidate it.
 397          $DB->delete_records('messageinbound_datakeys', array(
 398              'handler' => $handler->id,
 399              'datavalue' => $dataid,
 400          ));
 401  
 402          $parser->process($address);
 403          $result = $parser->validate($user->email);
 404          $expectedfail = \core\message\inbound\address_manager::VALIDATION_UNKNOWN_DATAKEY;
 405          $this->assertEquals($expectedfail, $result & $expectedfail);
 406      }
 407  
 408      /**
 409       * Test address parsing of an address for an expired key.
 410       */
 411      public function test_address_validation_expired_key() {
 412          global $DB;
 413  
 414          // Create test data.
 415          $user = $this->getDataGenerator()->create_user();
 416          $handler = $this->helper_create_handler('handler_one');
 417          $dataid = 42;
 418  
 419          $parser = new core_message_inbound_test_helper();
 420  
 421          $generator = new core_message_inbound_test_helper();
 422          $generator->set_handler($handler->classname);
 423          $generator->set_data($dataid);
 424          $address = $generator->generate($user->id);
 425  
 426          // Expire the key by setting it's expiry time in the past.
 427          $key = $DB->get_record('messageinbound_datakeys', array(
 428              'handler' => $handler->id,
 429              'datavalue' => $dataid,
 430          ));
 431  
 432          $key->expires = time() - 3600;
 433          $DB->update_record('messageinbound_datakeys', $key);
 434  
 435          $parser->process($address);
 436          $result = $parser->validate($user->email);
 437          $expectedfail = \core\message\inbound\address_manager::VALIDATION_EXPIRED_DATAKEY;
 438          $this->assertEquals($expectedfail, $result & $expectedfail);
 439      }
 440  
 441      /**
 442       * Test address parsing of an address for an invalid hash.
 443       */
 444      public function test_address_validation_invalid_hash() {
 445          global $DB;
 446  
 447          // Create test data.
 448          $user = $this->getDataGenerator()->create_user();
 449          $handler = $this->helper_create_handler('handler_one');
 450          $dataid = 42;
 451  
 452          $parser = new core_message_inbound_test_helper();
 453  
 454          $generator = new core_message_inbound_test_helper();
 455          $generator->set_handler($handler->classname);
 456          $generator->set_data($dataid);
 457          $address = $generator->generate($user->id);
 458  
 459          // Expire the key by setting it's expiry time in the past.
 460          $key = $DB->get_record('messageinbound_datakeys', array(
 461              'handler' => $handler->id,
 462              'datavalue' => $dataid,
 463          ));
 464  
 465          $key->datakey = 'invalid value';
 466          $DB->update_record('messageinbound_datakeys', $key);
 467  
 468          $parser->process($address);
 469          $result = $parser->validate($user->email);
 470          $expectedfail = \core\message\inbound\address_manager::VALIDATION_INVALID_HASH;
 471          $this->assertEquals($expectedfail, $result & $expectedfail);
 472      }
 473  
 474      /**
 475       * Test address parsing of an address for an invalid sender.
 476       */
 477      public function test_address_validation_invalid_sender() {
 478          global $DB;
 479  
 480          // Create test data.
 481          $user = $this->getDataGenerator()->create_user();
 482          $handler = $this->helper_create_handler('handler_one');
 483          $dataid = 42;
 484  
 485          $parser = new core_message_inbound_test_helper();
 486  
 487          $generator = new core_message_inbound_test_helper();
 488          $generator->set_handler($handler->classname);
 489          $generator->set_data($dataid);
 490          $address = $generator->generate($user->id);
 491  
 492          $parser->process($address);
 493          $result = $parser->validate('incorrectuser@example.com');
 494          $expectedfail = \core\message\inbound\address_manager::VALIDATION_ADDRESS_MISMATCH;
 495          $this->assertEquals($expectedfail, $result & $expectedfail);
 496      }
 497  
 498      /**
 499       * Test address parsing of an address for an address which is correct.
 500       */
 501      public function test_address_validation_success() {
 502          global $DB;
 503  
 504          // Create test data.
 505          $user = $this->getDataGenerator()->create_user();
 506          $handler = $this->helper_create_handler('handler_one');
 507          $dataid = 42;
 508  
 509          $parser = new core_message_inbound_test_helper();
 510  
 511          $generator = new core_message_inbound_test_helper();
 512          $generator->set_handler($handler->classname);
 513          $generator->set_data($dataid);
 514          $address = $generator->generate($user->id);
 515  
 516          $parser->process($address);
 517          $result = $parser->validate($user->email);
 518          $this->assertEquals(\core\message\inbound\address_manager::VALIDATION_SUCCESS, $result);
 519  
 520      }
 521  
 522      /**
 523       * Test that a handler with no default expiration does not have an
 524       * expiration time applied.
 525       */
 526      public function test_default_hander_expiry_unlimited() {
 527          global $DB;
 528  
 529          // Set the default expiry of the handler to 0 - no expiration.
 530          $expiration = 0;
 531  
 532          // Create test data.
 533          $user = $this->getDataGenerator()->create_user();
 534          $handler = $this->helper_create_handler('handler_one');
 535  
 536          $record = \core\message\inbound\manager::record_from_handler($handler);
 537          $record->defaultexpiration = $expiration;
 538          $DB->update_record('messageinbound_handlers', $record);
 539  
 540          // Generate an address for the handler.
 541          $dataid = 42;
 542  
 543          $generator = new core_message_inbound_test_helper();
 544          $generator->set_handler($handler->classname);
 545          $generator->set_data($dataid);
 546          $address = $generator->generate($user->id);
 547  
 548          // Check that the datakey created matches the expirytime.
 549          $key = $DB->get_record('messageinbound_datakeys', array('handler' => $record->id, 'datavalue' => $dataid));
 550  
 551          $this->assertNull($key->expires);
 552      }
 553  
 554      /**
 555       * Test application of the default expiry on a handler.
 556       */
 557      public function test_default_hander_expiry_low() {
 558          global $DB;
 559  
 560          // Set the default expiry of the handler to 60 seconds.
 561          $expiration = 60;
 562  
 563          // Create test data.
 564          $user = $this->getDataGenerator()->create_user();
 565          $handler = $this->helper_create_handler('handler_one');
 566  
 567          $record = \core\message\inbound\manager::record_from_handler($handler);
 568          $record->defaultexpiration = $expiration;
 569          $DB->update_record('messageinbound_handlers', $record);
 570  
 571          // Generate an address for the handler.
 572          $dataid = 42;
 573  
 574          $generator = new core_message_inbound_test_helper();
 575          $generator->set_handler($handler->classname);
 576          $generator->set_data($dataid);
 577          $address = $generator->generate($user->id);
 578  
 579          // Check that the datakey created matches the expirytime.
 580          $key = $DB->get_record('messageinbound_datakeys', array('handler' => $record->id, 'datavalue' => $dataid));
 581  
 582          $this->assertEquals($key->timecreated + $expiration, $key->expires);
 583      }
 584  
 585      /**
 586       * Test application of the default expiry on a handler.
 587       */
 588      public function test_default_hander_expiry_medium() {
 589          global $DB;
 590  
 591          // Set the default expiry of the handler to 3600 seconds.
 592          $expiration = 3600;
 593  
 594          // Create test data.
 595          $user = $this->getDataGenerator()->create_user();
 596          $handler = $this->helper_create_handler('handler_one');
 597  
 598          $record = \core\message\inbound\manager::record_from_handler($handler);
 599          $record->defaultexpiration = $expiration;
 600          $DB->update_record('messageinbound_handlers', $record);
 601  
 602          // Generate an address for the handler.
 603          $dataid = 42;
 604  
 605          $generator = new core_message_inbound_test_helper();
 606          $generator->set_handler($handler->classname);
 607          $generator->set_data($dataid);
 608          $address = $generator->generate($user->id);
 609  
 610          // Check that the datakey created matches the expirytime.
 611          $key = $DB->get_record('messageinbound_datakeys', array('handler' => $record->id, 'datavalue' => $dataid));
 612  
 613          $this->assertEquals($key->timecreated + $expiration, $key->expires);
 614      }
 615  
 616  }
 617  
 618  /**
 619   * A helper function for unit testing to expose protected functions in the core_message_inbound API for testing.
 620   *
 621   * @copyright  2014 Andrew Nicols <andrew@nicols.co.uk>
 622   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 623   */
 624  class core_message_inbound_test_helper extends \core\message\inbound\address_manager {
 625      /**
 626       * The validate function.
 627       *
 628       * @param string $address
 629       * @return int
 630       */
 631      public function validate($address) {
 632          return parent::validate($address);
 633      }
 634  
 635      /**
 636       * The get_data function.
 637       *
 638       * @return stdClass
 639       */
 640      public function get_data() {
 641          return parent::get_data();
 642      }
 643  
 644      /**
 645       * The address processor function.
 646       *
 647       * @param string $address
 648       * @return void
 649       */
 650      public function process($address) {
 651          return parent::process($address);
 652      }
 653  }
 654  
 655  /**
 656   * A helper function for unit testing to expose protected functions in the core_message_inbound API for testing.
 657   *
 658   * @copyright  2014 Andrew Nicols <andrew@nicols.co.uk>
 659   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 660   */
 661  class core_message_inbound_test_manager extends \core\message\inbound\manager {
 662      /**
 663       * Helper to fetch make the handler_from_record public for unit testing.
 664       *
 665       * @param $record The handler record to fetch
 666       */
 667      public static function handler_from_record($record) {
 668          return parent::handler_from_record($record);
 669      }
 670  }