v8  3.11.10(node0.8.26)
V8 is Google's open source JavaScript engine
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
test-list.cc
Go to the documentation of this file.
1 // Copyright 2011 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
28 #include <stdlib.h>
29 #include <string.h>
30 #include "v8.h"
31 #include "cctest.h"
32 
33 using namespace v8::internal;
34 
35 // Use a testing allocator that clears memory before deletion.
37  public:
38  void* New(size_t size) {
39  // Stash the size in the first word to use for Delete.
40  size_t true_size = size + sizeof(size_t);
41  size_t* result = reinterpret_cast<size_t*>(malloc(true_size));
42  if (result == NULL) return result;
43  *result = true_size;
44  return result + 1;
45  }
46 
47  static void Delete(void* ptr) {
48  size_t* true_ptr = reinterpret_cast<size_t*>(ptr) - 1;
49  memset(true_ptr, 0, *true_ptr);
50  free(true_ptr);
51  }
52 };
53 
54 // Check that we can add (a reference to) an element of the list
55 // itself.
56 TEST(ListAdd) {
57  // Add elements to the list to grow it to its capacity.
59  list.Add(1);
60  list.Add(2);
61  list.Add(3);
62  list.Add(4);
63 
64  // Add an existing element, the backing store should have to grow.
65  list.Add(list[0]);
66  CHECK_EQ(1, list[4]);
67 }
68 
69 // Test that we can add all elements from a list to another list.
70 TEST(ListAddAll) {
72  list.Add(0);
73  list.Add(1);
74  list.Add(2);
75 
76  CHECK_EQ(3, list.length());
77  for (int i = 0; i < 3; i++) {
78  CHECK_EQ(i, list[i]);
79  }
80 
82 
83  // Add no elements to list since other_list is empty.
84  list.AddAll(other_list);
85  CHECK_EQ(3, list.length());
86  for (int i = 0; i < 3; i++) {
87  CHECK_EQ(i, list[i]);
88  }
89 
90  // Add three elements to other_list.
91  other_list.Add(0);
92  other_list.Add(1);
93  other_list.Add(2);
94 
95  // Copy the three elements from other_list to list.
96  list.AddAll(other_list);
97  CHECK_EQ(6, list.length());
98  for (int i = 0; i < 6; i++) {
99  CHECK_EQ(i % 3, list[i]);
100  }
101 }
102 
103 
104 TEST(RemoveLast) {
105  List<int> list(4);
106  CHECK_EQ(0, list.length());
107  list.Add(1);
108  CHECK_EQ(1, list.length());
109  CHECK_EQ(1, list.last());
110  list.RemoveLast();
111  CHECK_EQ(0, list.length());
112  list.Add(2);
113  list.Add(3);
114  CHECK_EQ(2, list.length());
115  CHECK_EQ(3, list.last());
116  list.RemoveLast();
117  CHECK_EQ(1, list.length());
118  CHECK_EQ(2, list.last());
119  list.RemoveLast();
120  CHECK_EQ(0, list.length());
121 
122  const int kElements = 100;
123  for (int i = 0; i < kElements; i++) list.Add(i);
124  for (int j = kElements - 1; j >= 0; j--) {
125  CHECK_EQ(j + 1, list.length());
126  CHECK_EQ(j, list.last());
127  list.RemoveLast();
128  CHECK_EQ(j, list.length());
129  }
130 }
131 
132 
133 TEST(Allocate) {
134  List<int> list(4);
135  list.Add(1);
136  CHECK_EQ(1, list.length());
137  list.Allocate(100);
138  CHECK_EQ(100, list.length());
139  CHECK_LE(100, list.capacity());
140  list[99] = 123;
141  CHECK_EQ(123, list[99]);
142 }
143 
144 
145 TEST(Clear) {
146  List<int> list(4);
147  CHECK_EQ(0, list.length());
148  for (int i = 0; i < 4; ++i) list.Add(i);
149  CHECK_EQ(4, list.length());
150  list.Clear();
151  CHECK_EQ(0, list.length());
152 }
153 
154 
155 TEST(DeleteEmpty) {
156  {
157  List<int>* list = new List<int>(0);
158  delete list;
159  }
160  {
161  List<int> list(0);
162  }
163 }
#define CHECK_EQ(expected, value)
Definition: checks.h:219
T & last() const
Definition: list.h:86
static void Delete(void *ptr)
Definition: test-list.cc:47
#define CHECK_LE(a, b)
Definition: checks.h:230
void * New(size_t size)
Definition: test-list.cc:38
activate correct semantics for inheriting readonliness enable harmony semantics for typeof enable harmony enable harmony proxies enable all harmony harmony_scoping harmony_proxies harmony_scoping tracks arrays with only smi values automatically unbox arrays of doubles use crankshaft use hydrogen range analysis use hydrogen global value numbering use function inlining maximum number of AST nodes considered for a single inlining loop invariant code motion print statistics for hydrogen trace generated IR for specified phases trace register allocator trace range analysis trace representation types environment for every instruction put a break point before deoptimizing polymorphic inlining perform array bounds checks elimination trace on stack replacement optimize closures functions with arguments object optimize functions containing for in loops profiler considers IC stability primitive functions trigger their own optimization re try self optimization if it failed insert an interrupt check at function exit execution budget before interrupt is triggered call count before self optimization self_optimization count_based_interrupts weighted_back_edges trace_opt emit comments in code disassembly enable use of SSE3 instructions if available enable use of CMOV instruction if available enable use of SAHF instruction if enable use of VFP3 instructions if available this implies enabling ARMv7 enable use of ARMv7 instructions if enable use of MIPS FPU instructions if NULL
Definition: flags.cc:274
void Add(const T &element, AllocationPolicy allocator=AllocationPolicy())
Definition: list-inl.h:38
void AddAll(const List< T, AllocationPolicy > &other, AllocationPolicy allocator=AllocationPolicy())