src/breakpad/src/processor/fast_source_line_resolver_unittest.cc

   1 // Copyright (c) 2010 Google Inc.
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are
   6 // met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright
   9 // notice, this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above
  11 // copyright notice, this list of conditions and the following disclaimer
  12 // in the documentation and/or other materials provided with the
  13 // distribution.
  14 //     * Neither the name of Google Inc. nor the names of its
  15 // contributors may be used to endorse or promote products derived from
  16 // this software without specific prior written permission.
  17 //
  18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 //
  30 // fast_source_line_resolver_unittest.cc: Unit tests for FastSourceLineResolver.
  31 // Two different approaches for testing fast source line resolver:
  32 // First, use the same unit test data for basic source line resolver.
  33 // Second, read data from symbol files, load them as basic modules, and then
  34 // serialize them and load the serialized data as fast modules.  Then compare
  35 // modules to assure the fast module contains exactly the same data as
  36 // basic module.
  37 //
  38 // Author: Siyang Xie (lambxsy@google.com)
  39
  40 #include <assert.h>
  41 #include <stdio.h>
  42
  43 #include <sstream>
  44 #include <string>
  45
  46 #include "breakpad_googletest_includes.h"
  47 #include "common/using_std_string.h"
  48 #include "google_breakpad/processor/code_module.h"
  49 #include "google_breakpad/processor/stack_frame.h"
  50 #include "google_breakpad/processor/memory_region.h"
  51 #include "processor/logging.h"
  52 #include "processor/module_serializer.h"
  53 #include "processor/module_comparer.h"
  54
  55 namespace {
  56
  57 using google_breakpad::SourceLineResolverBase;
  58 using google_breakpad::BasicSourceLineResolver;
  59 using google_breakpad::FastSourceLineResolver;
  60 using google_breakpad::ModuleSerializer;
  61 using google_breakpad::ModuleComparer;
  62 using google_breakpad::CFIFrameInfo;
  63 using google_breakpad::CodeModule;
  64 using google_breakpad::MemoryRegion;
  65 using google_breakpad::StackFrame;
  66 using google_breakpad::WindowsFrameInfo;
  67 using google_breakpad::linked_ptr;
  68 using google_breakpad::scoped_ptr;
  69
  70 class TestCodeModule : public CodeModule {
  71  public:
  72   explicit TestCodeModule(string code_file) : code_file_(code_file) {}
  73   virtual ~TestCodeModule() {}
  74
  75   virtual uint64_t base_address() const { return 0; }
  76   virtual uint64_t size() const { return 0xb000; }
  77   virtual string code_file() const { return code_file_; }
  78   virtual string code_identifier() const { return ""; }
  79   virtual string debug_file() const { return ""; }
  80   virtual string debug_identifier() const { return ""; }
  81   virtual string version() const { return ""; }
  82   virtual const CodeModule* Copy() const {
  83     return new TestCodeModule(code_file_);
  84   }
  85
  86  private:
  87   string code_file_;
  88 };
  89
  90 // A mock memory region object, for use by the STACK CFI tests.
  91 class MockMemoryRegion: public MemoryRegion {
  92   uint64_t GetBase() const { return 0x10000; }
  93   uint32_t GetSize() const { return 0x01000; }
  94   bool GetMemoryAtAddress(uint64_t address, uint8_t *value) const {
  95     *value = address & 0xff;
  96     return true;
  97   }
  98   bool GetMemoryAtAddress(uint64_t address, uint16_t *value) const {
  99     *value = address & 0xffff;
 100     return true;
 101   }
 102   bool GetMemoryAtAddress(uint64_t address, uint32_t *value) const {
 103     switch (address) {
 104       case 0x10008: *value = 0x98ecadc3; break;  // saved %ebx
 105       case 0x1000c: *value = 0x878f7524; break;  // saved %esi
 106       case 0x10010: *value = 0x6312f9a5; break;  // saved %edi
 107       case 0x10014: *value = 0x10038;    break;  // caller's %ebp
 108       case 0x10018: *value = 0xf6438648; break;  // return address
 109       default: *value = 0xdeadbeef;      break;  // junk
 110     }
 111     return true;
 112   }
 113   bool GetMemoryAtAddress(uint64_t address, uint64_t *value) const {
 114     *value = address;
 115     return true;
 116   }
 117   void Print() const {
 118     assert(false);
 119   }
 120 };
 121
 122 // Verify that, for every association in ACTUAL, EXPECTED has the same
 123 // association. (That is, ACTUAL's associations should be a subset of
 124 // EXPECTED's.) Also verify that ACTUAL has associations for ".ra" and
 125 // ".cfa".
 126 static bool VerifyRegisters(
 127     const char *file, int line,
 128     const CFIFrameInfo::RegisterValueMap<uint32_t> &expected,
 129     const CFIFrameInfo::RegisterValueMap<uint32_t> &actual) {
 130   CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator a;
 131   a = actual.find(".cfa");
 132   if (a == actual.end())
 133     return false;
 134   a = actual.find(".ra");
 135   if (a == actual.end())
 136     return false;
 137   for (a = actual.begin(); a != actual.end(); a++) {
 138     CFIFrameInfo::RegisterValueMap<uint32_t>::const_iterator e =
 139       expected.find(a->first);
 140     if (e == expected.end()) {
 141       fprintf(stderr, "%s:%d: unexpected register '%s' recovered, value 0x%x\n",
 142               file, line, a->first.c_str(), a->second);
 143       return false;
 144     }
 145     if (e->second != a->second) {
 146       fprintf(stderr,
 147               "%s:%d: register '%s' recovered value was 0x%x, expected 0x%x\n",
 148               file, line, a->first.c_str(), a->second, e->second);
 149       return false;
 150     }
 151     // Don't complain if this doesn't recover all registers. Although
 152     // the DWARF spec says that unmentioned registers are undefined,
 153     // GCC uses omission to mean that they are unchanged.
 154   }
 155   return true;
 156 }
 157
 158 static bool VerifyEmpty(const StackFrame &frame) {
 159   if (frame.function_name.empty() &&
 160       frame.source_file_name.empty() &&
 161       frame.source_line == 0)
 162     return true;
 163   return false;
 164 }
 165
 166 static void ClearSourceLineInfo(StackFrame *frame) {
 167   frame->function_name.clear();
 168   frame->module = NULL;
 169   frame->source_file_name.clear();
 170   frame->source_line = 0;
 171 }
 172
 173 class TestFastSourceLineResolver : public ::testing::Test {
 174  public:
 175   void SetUp() {
 176     testdata_dir = string(getenv("srcdir") ? getenv("srcdir") : ".") +
 177                          "/src/processor/testdata";
 178   }
 179
 180   string symbol_file(int file_index) {
 181     std::stringstream ss;
 182     ss << testdata_dir << "/module" << file_index << ".out";
 183     return ss.str();
 184   }
 185
 186   ModuleSerializer serializer;
 187   BasicSourceLineResolver basic_resolver;
 188   FastSourceLineResolver fast_resolver;
 189   ModuleComparer module_comparer;
 190
 191   string testdata_dir;
 192 };
 193
 194 // Test adapted from basic_source_line_resolver_unittest.
 195 TEST_F(TestFastSourceLineResolver, TestLoadAndResolve) {
 196   TestCodeModule module1("module1");
 197   ASSERT_TRUE(basic_resolver.LoadModule(&module1, symbol_file(1)));
 198   ASSERT_TRUE(basic_resolver.HasModule(&module1));
 199   // Convert module1 to fast_module:
 200   ASSERT_TRUE(serializer.ConvertOneModule(
 201       module1.code_file(), &basic_resolver, &fast_resolver));
 202   ASSERT_TRUE(fast_resolver.HasModule(&module1));
 203
 204   TestCodeModule module2("module2");
 205   ASSERT_TRUE(basic_resolver.LoadModule(&module2, symbol_file(2)));
 206   ASSERT_TRUE(basic_resolver.HasModule(&module2));
 207   // Convert module2 to fast_module:
 208   ASSERT_TRUE(serializer.ConvertOneModule(
 209       module2.code_file(), &basic_resolver, &fast_resolver));
 210   ASSERT_TRUE(fast_resolver.HasModule(&module2));
 211
 212   StackFrame frame;
 213   scoped_ptr<WindowsFrameInfo> windows_frame_info;
 214   scoped_ptr<CFIFrameInfo> cfi_frame_info;
 215   frame.instruction = 0x1000;
 216   frame.module = NULL;
 217   fast_resolver.FillSourceLineInfo(&frame);
 218   ASSERT_FALSE(frame.module);
 219   ASSERT_TRUE(frame.function_name.empty());
 220   ASSERT_EQ(frame.function_base, 0U);
 221   ASSERT_TRUE(frame.source_file_name.empty());
 222   ASSERT_EQ(frame.source_line, 0);
 223   ASSERT_EQ(frame.source_line_base, 0U);
 224
 225   frame.module = &module1;
 226   fast_resolver.FillSourceLineInfo(&frame);
 227   ASSERT_EQ(frame.function_name, "Function1_1");
 228   ASSERT_TRUE(frame.module);
 229   ASSERT_EQ(frame.module->code_file(), "module1");
 230   ASSERT_EQ(frame.function_base, 0x1000U);
 231   ASSERT_EQ(frame.source_file_name, "file1_1.cc");
 232   ASSERT_EQ(frame.source_line, 44);
 233   ASSERT_EQ(frame.source_line_base, 0x1000U);
 234   windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame));
 235   ASSERT_TRUE(windows_frame_info.get());
 236   ASSERT_FALSE(windows_frame_info->allocates_base_pointer);
 237   ASSERT_EQ(windows_frame_info->program_string,
 238             "$eip 4 + ^ = $esp $ebp 8 + = $ebp $ebp ^ =");
 239
 240   ClearSourceLineInfo(&frame);
 241   frame.instruction = 0x800;
 242   frame.module = &module1;
 243   fast_resolver.FillSourceLineInfo(&frame);
 244   ASSERT_TRUE(VerifyEmpty(frame));
 245   windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame));
 246   ASSERT_FALSE(windows_frame_info.get());
 247
 248   frame.instruction = 0x1280;
 249   fast_resolver.FillSourceLineInfo(&frame);
 250   ASSERT_EQ(frame.function_name, "Function1_3");
 251   ASSERT_TRUE(frame.source_file_name.empty());
 252   ASSERT_EQ(frame.source_line, 0);
 253   windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame));
 254   ASSERT_TRUE(windows_frame_info.get());
 255   ASSERT_EQ(windows_frame_info->type_, WindowsFrameInfo::STACK_INFO_UNKNOWN);
 256   ASSERT_FALSE(windows_frame_info->allocates_base_pointer);
 257   ASSERT_TRUE(windows_frame_info->program_string.empty());
 258
 259   frame.instruction = 0x1380;
 260   fast_resolver.FillSourceLineInfo(&frame);
 261   ASSERT_EQ(frame.function_name, "Function1_4");
 262   ASSERT_TRUE(frame.source_file_name.empty());
 263   ASSERT_EQ(frame.source_line, 0);
 264   windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame));
 265   ASSERT_TRUE(windows_frame_info.get());
 266   ASSERT_EQ(windows_frame_info->type_, WindowsFrameInfo::STACK_INFO_FRAME_DATA);
 267   ASSERT_FALSE(windows_frame_info->allocates_base_pointer);
 268   ASSERT_FALSE(windows_frame_info->program_string.empty());
 269
 270   frame.instruction = 0x2000;
 271   windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame));
 272   ASSERT_FALSE(windows_frame_info.get());
 273
 274   // module1 has STACK CFI records covering 3d40..3def;
 275   // module2 has STACK CFI records covering 3df0..3e9f;
 276   // check that FindCFIFrameInfo doesn't claim to find any outside those ranges.
 277   frame.instruction = 0x3d3f;
 278   frame.module = &module1;
 279   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
 280   ASSERT_FALSE(cfi_frame_info.get());
 281
 282   frame.instruction = 0x3e9f;
 283   frame.module = &module1;
 284   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
 285   ASSERT_FALSE(cfi_frame_info.get());
 286
 287   CFIFrameInfo::RegisterValueMap<uint32_t> current_registers;
 288   CFIFrameInfo::RegisterValueMap<uint32_t> caller_registers;
 289   CFIFrameInfo::RegisterValueMap<uint32_t> expected_caller_registers;
 290   MockMemoryRegion memory;
 291
 292   // Regardless of which instruction evaluation takes place at, it
 293   // should produce the same values for the caller's registers.
 294   expected_caller_registers[".cfa"] = 0x1001c;
 295   expected_caller_registers[".ra"]  = 0xf6438648;
 296   expected_caller_registers["$ebp"] = 0x10038;
 297   expected_caller_registers["$ebx"] = 0x98ecadc3;
 298   expected_caller_registers["$esi"] = 0x878f7524;
 299   expected_caller_registers["$edi"] = 0x6312f9a5;
 300
 301   frame.instruction = 0x3d40;
 302   frame.module = &module1;
 303   current_registers.clear();
 304   current_registers["$esp"] = 0x10018;
 305   current_registers["$ebp"] = 0x10038;
 306   current_registers["$ebx"] = 0x98ecadc3;
 307   current_registers["$esi"] = 0x878f7524;
 308   current_registers["$edi"] = 0x6312f9a5;
 309   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
 310   ASSERT_TRUE(cfi_frame_info.get());
 311   ASSERT_TRUE(cfi_frame_info.get()
 312               ->FindCallerRegs<uint32_t>(current_registers, memory,
 313                                           &caller_registers));
 314   ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__,
 315                               expected_caller_registers, caller_registers));
 316
 317   frame.instruction = 0x3d41;
 318   current_registers["$esp"] = 0x10014;
 319   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
 320   ASSERT_TRUE(cfi_frame_info.get());
 321   ASSERT_TRUE(cfi_frame_info.get()
 322               ->FindCallerRegs<uint32_t>(current_registers, memory,
 323                                           &caller_registers));
 324   ASSERT_TRUE(VerifyRegisters(__FILE__, __LINE__,
 325                               expected_caller_registers, caller_registers));
 326
 327   frame.instruction = 0x3d43;
 328   current_registers["$ebp"] = 0x10014;
 329   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
 330   ASSERT_TRUE(cfi_frame_info.get());
 331   ASSERT_TRUE(cfi_frame_info.get()
 332               ->FindCallerRegs<uint32_t>(current_registers, memory,
 333                                           &caller_registers));
 334   VerifyRegisters(__FILE__, __LINE__,
 335                   expected_caller_registers, caller_registers);
 336
 337   frame.instruction = 0x3d54;
 338   current_registers["$ebx"] = 0x6864f054U;
 339   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
 340   ASSERT_TRUE(cfi_frame_info.get());
 341   ASSERT_TRUE(cfi_frame_info.get()
 342               ->FindCallerRegs<uint32_t>(current_registers, memory,
 343                                           &caller_registers));
 344   VerifyRegisters(__FILE__, __LINE__,
 345                   expected_caller_registers, caller_registers);
 346
 347   frame.instruction = 0x3d5a;
 348   current_registers["$esi"] = 0x6285f79aU;
 349   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
 350   ASSERT_TRUE(cfi_frame_info.get());
 351   ASSERT_TRUE(cfi_frame_info.get()
 352               ->FindCallerRegs<uint32_t>(current_registers, memory,
 353                                           &caller_registers));
 354   VerifyRegisters(__FILE__, __LINE__,
 355                   expected_caller_registers, caller_registers);
 356
 357   frame.instruction = 0x3d84;
 358   current_registers["$edi"] = 0x64061449U;
 359   cfi_frame_info.reset(fast_resolver.FindCFIFrameInfo(&frame));
 360   ASSERT_TRUE(cfi_frame_info.get());
 361   ASSERT_TRUE(cfi_frame_info.get()
 362               ->FindCallerRegs<uint32_t>(current_registers, memory,
 363                                           &caller_registers));
 364   VerifyRegisters(__FILE__, __LINE__,
 365                   expected_caller_registers, caller_registers);
 366
 367   frame.instruction = 0x2900;
 368   frame.module = &module1;
 369   fast_resolver.FillSourceLineInfo(&frame);
 370   ASSERT_EQ(frame.function_name, string("PublicSymbol"));
 371
 372   frame.instruction = 0x4000;
 373   frame.module = &module1;
 374   fast_resolver.FillSourceLineInfo(&frame);
 375   ASSERT_EQ(frame.function_name, string("LargeFunction"));
 376
 377   frame.instruction = 0x2181;
 378   frame.module = &module2;
 379   fast_resolver.FillSourceLineInfo(&frame);
 380   ASSERT_EQ(frame.function_name, "Function2_2");
 381   ASSERT_EQ(frame.function_base, 0x2170U);
 382   ASSERT_TRUE(frame.module);
 383   ASSERT_EQ(frame.module->code_file(), "module2");
 384   ASSERT_EQ(frame.source_file_name, "file2_2.cc");
 385   ASSERT_EQ(frame.source_line, 21);
 386   ASSERT_EQ(frame.source_line_base, 0x2180U);
 387   windows_frame_info.reset(fast_resolver.FindWindowsFrameInfo(&frame));
 388   ASSERT_TRUE(windows_frame_info.get());
 389   ASSERT_EQ(windows_frame_info->type_, WindowsFrameInfo::STACK_INFO_FRAME_DATA);
 390   ASSERT_EQ(windows_frame_info->prolog_size, 1U);
 391
 392   frame.instruction = 0x216f;
 393   fast_resolver.FillSourceLineInfo(&frame);
 394   ASSERT_EQ(frame.function_name, "Public2_1");
 395
 396   ClearSourceLineInfo(&frame);
 397   frame.instruction = 0x219f;
 398   frame.module = &module2;
 399   fast_resolver.FillSourceLineInfo(&frame);
 400   ASSERT_TRUE(frame.function_name.empty());
 401
 402   frame.instruction = 0x21a0;
 403   frame.module = &module2;
 404   fast_resolver.FillSourceLineInfo(&frame);
 405   ASSERT_EQ(frame.function_name, "Public2_2");
 406 }
 407
 408 TEST_F(TestFastSourceLineResolver, TestInvalidLoads) {
 409   TestCodeModule module3("module3");
 410   ASSERT_TRUE(basic_resolver.LoadModule(&module3,
 411                                         testdata_dir + "/module3_bad.out"));
 412   ASSERT_TRUE(basic_resolver.HasModule(&module3));
 413   ASSERT_TRUE(basic_resolver.IsModuleCorrupt(&module3));
 414   // Convert module3 to fast_module:
 415   ASSERT_TRUE(serializer.ConvertOneModule(module3.code_file(),
 416                                           &basic_resolver,
 417                                           &fast_resolver));
 418   ASSERT_TRUE(fast_resolver.HasModule(&module3));
 419   ASSERT_TRUE(fast_resolver.IsModuleCorrupt(&module3));
 420
 421   TestCodeModule module4("module4");
 422   ASSERT_TRUE(basic_resolver.LoadModule(&module4,
 423                                         testdata_dir + "/module4_bad.out"));
 424   ASSERT_TRUE(basic_resolver.HasModule(&module4));
 425   ASSERT_TRUE(basic_resolver.IsModuleCorrupt(&module4));
 426   // Convert module4 to fast_module:
 427   ASSERT_TRUE(serializer.ConvertOneModule(module4.code_file(),
 428                                           &basic_resolver,
 429                                           &fast_resolver));
 430   ASSERT_TRUE(fast_resolver.HasModule(&module4));
 431   ASSERT_TRUE(fast_resolver.IsModuleCorrupt(&module4));
 432
 433   TestCodeModule module5("module5");
 434   ASSERT_FALSE(fast_resolver.LoadModule(&module5,
 435                                         testdata_dir + "/invalid-filename"));
 436   ASSERT_FALSE(fast_resolver.HasModule(&module5));
 437
 438   TestCodeModule invalidmodule("invalid-module");
 439   ASSERT_FALSE(fast_resolver.HasModule(&invalidmodule));
 440 }
 441
 442 TEST_F(TestFastSourceLineResolver, TestUnload) {
 443   TestCodeModule module1("module1");
 444   ASSERT_FALSE(basic_resolver.HasModule(&module1));
 445
 446   ASSERT_TRUE(basic_resolver.LoadModule(&module1, symbol_file(1)));
 447   ASSERT_TRUE(basic_resolver.HasModule(&module1));
 448   // Convert module1 to fast_module.
 449   ASSERT_TRUE(serializer.ConvertOneModule(module1.code_file(),
 450                                           &basic_resolver,
 451                                           &fast_resolver));
 452   ASSERT_TRUE(fast_resolver.HasModule(&module1));
 453   basic_resolver.UnloadModule(&module1);
 454   fast_resolver.UnloadModule(&module1);
 455   ASSERT_FALSE(fast_resolver.HasModule(&module1));
 456
 457   ASSERT_TRUE(basic_resolver.LoadModule(&module1, symbol_file(1)));
 458   ASSERT_TRUE(basic_resolver.HasModule(&module1));
 459   // Convert module1 to fast_module.
 460   ASSERT_TRUE(serializer.ConvertOneModule(module1.code_file(),
 461                                           &basic_resolver,
 462                                           &fast_resolver));
 463   ASSERT_TRUE(fast_resolver.HasModule(&module1));
 464 }
 465
 466 TEST_F(TestFastSourceLineResolver, CompareModule) {
 467   char *symbol_data;
 468   size_t symbol_data_size;
 469   string symbol_data_string;
 470   string filename;
 471
 472   for (int module_index = 0; module_index < 3; ++module_index) {
 473     std::stringstream ss;
 474     ss << testdata_dir << "/module" << module_index << ".out";
 475     filename = ss.str();
 476     ASSERT_TRUE(SourceLineResolverBase::ReadSymbolFile(
 477         symbol_file(module_index), &symbol_data, &symbol_data_size));
 478     symbol_data_string.assign(symbol_data, symbol_data_size);
 479     delete [] symbol_data;
 480     ASSERT_TRUE(module_comparer.Compare(symbol_data_string));
 481   }
 482 }
 483
 484 }  // namespace
 485
 486 int main(int argc, char *argv[]) {
 487   ::testing::InitGoogleTest(&argc, argv);
 488   return RUN_ALL_TESTS();
 489 }