| OLD | NEW |
|---|
| (Empty) |
| 1 # Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 # Use of this source code is governed by a BSD-style license that can be | |
| 3 # found in the LICENSE file. | |
| 4 | |
| 5 import sys | |
| 6 | |
| 7 import module as mojom | |
| 8 import pack | |
| 9 import test_support | |
| 10 | |
| 11 | |
| 12 EXPECT_EQ = test_support.EXPECT_EQ | |
| 13 EXPECT_TRUE = test_support.EXPECT_TRUE | |
| 14 RunTest = test_support.RunTest | |
| 15 | |
| 16 | |
| 17 def TestOrdinalOrder(): | |
| 18 errors = 0 | |
| 19 struct = mojom.Struct('test') | |
| 20 struct.AddField('testfield1', mojom.INT32, 2) | |
| 21 struct.AddField('testfield2', mojom.INT32, 1) | |
| 22 ps = pack.PackedStruct(struct) | |
| 23 | |
| 24 errors += EXPECT_EQ(2, len(ps.packed_fields)) | |
| 25 errors += EXPECT_EQ('testfield2', ps.packed_fields[0].field.name) | |
| 26 errors += EXPECT_EQ('testfield1', ps.packed_fields[1].field.name) | |
| 27 | |
| 28 return errors | |
| 29 | |
| 30 def TestZeroFields(): | |
| 31 errors = 0 | |
| 32 struct = mojom.Struct('test') | |
| 33 ps = pack.PackedStruct(struct) | |
| 34 errors += EXPECT_EQ(0, len(ps.packed_fields)) | |
| 35 return errors | |
| 36 | |
| 37 | |
| 38 def TestOneField(): | |
| 39 errors = 0 | |
| 40 struct = mojom.Struct('test') | |
| 41 struct.AddField('testfield1', mojom.INT8) | |
| 42 ps = pack.PackedStruct(struct) | |
| 43 errors += EXPECT_EQ(1, len(ps.packed_fields)) | |
| 44 return errors | |
| 45 | |
| 46 # Pass three tuples. | |
| 47 # |kinds| is a sequence of mojom.Kinds that specify the fields that are to | |
| 48 # be created. | |
| 49 # |fields| is the expected order of the resulting fields, with the integer | |
| 50 # "1" first. | |
| 51 # |offsets| is the expected order of offsets, with the integer "0" first. | |
| 52 def TestSequence(kinds, fields, offsets): | |
| 53 errors = 0 | |
| 54 struct = mojom.Struct('test') | |
| 55 index = 1 | |
| 56 for kind in kinds: | |
| 57 struct.AddField("%d" % index, kind) | |
| 58 index += 1 | |
| 59 ps = pack.PackedStruct(struct) | |
| 60 num_fields = len(ps.packed_fields) | |
| 61 errors += EXPECT_EQ(len(kinds), num_fields) | |
| 62 for i in xrange(num_fields): | |
| 63 EXPECT_EQ("%d" % fields[i], ps.packed_fields[i].field.name) | |
| 64 EXPECT_EQ(offsets[i], ps.packed_fields[i].offset) | |
| 65 | |
| 66 return errors | |
| 67 | |
| 68 | |
| 69 def TestPaddingPackedInOrder(): | |
| 70 return TestSequence( | |
| 71 (mojom.INT8, mojom.UINT8, mojom.INT32), | |
| 72 (1, 2, 3), | |
| 73 (0, 1, 4)) | |
| 74 | |
| 75 | |
| 76 def TestPaddingPackedOutOfOrder(): | |
| 77 return TestSequence( | |
| 78 (mojom.INT8, mojom.INT32, mojom.UINT8), | |
| 79 (1, 3, 2), | |
| 80 (0, 1, 4)) | |
| 81 | |
| 82 | |
| 83 def TestPaddingPackedOverflow(): | |
| 84 kinds = (mojom.INT8, mojom.INT32, mojom.INT16, mojom.INT8, mojom.INT8) | |
| 85 # 2 bytes should be packed together first, followed by short, then by int. | |
| 86 fields = (1, 4, 3, 2, 5) | |
| 87 offsets = (0, 1, 2, 4, 8) | |
| 88 return TestSequence(kinds, fields, offsets) | |
| 89 | |
| 90 | |
| 91 def TestNullableTypes(): | |
| 92 kinds = (mojom.STRING.MakeNullableKind(), | |
| 93 mojom.HANDLE.MakeNullableKind(), | |
| 94 mojom.Struct('test_struct').MakeNullableKind(), | |
| 95 mojom.DCPIPE.MakeNullableKind(), | |
| 96 mojom.Array().MakeNullableKind(), | |
| 97 mojom.DPPIPE.MakeNullableKind(), | |
| 98 mojom.Array(length=5).MakeNullableKind(), | |
| 99 mojom.MSGPIPE.MakeNullableKind(), | |
| 100 mojom.Interface('test_inteface').MakeNullableKind(), | |
| 101 mojom.SHAREDBUFFER.MakeNullableKind(), | |
| 102 mojom.InterfaceRequest().MakeNullableKind()) | |
| 103 fields = (1, 2, 4, 3, 5, 6, 8, 7, 9, 10, 11) | |
| 104 offsets = (0, 8, 12, 16, 24, 32, 36, 40, 48, 52, 56) | |
| 105 return TestSequence(kinds, fields, offsets) | |
| 106 | |
| 107 | |
| 108 def TestAllTypes(): | |
| 109 return TestSequence( | |
| 110 (mojom.BOOL, mojom.INT8, mojom.STRING, mojom.UINT8, | |
| 111 mojom.INT16, mojom.DOUBLE, mojom.UINT16, | |
| 112 mojom.INT32, mojom.UINT32, mojom.INT64, | |
| 113 mojom.FLOAT, mojom.STRING, mojom.HANDLE, | |
| 114 mojom.UINT64, mojom.Struct('test'), mojom.Array(), | |
| 115 mojom.STRING.MakeNullableKind()), | |
| 116 (1, 2, 4, 5, 7, 3, 6, 8, 9, 10, 11, 13, 12, 14, 15, 16, 17, 18), | |
| 117 (0, 1, 2, 4, 6, 8, 16, 24, 28, 32, 40, 44, 48, 56, 64, 72, 80, 88)) | |
| 118 | |
| 119 | |
| 120 def TestPaddingPackedOutOfOrderByOrdinal(): | |
| 121 errors = 0 | |
| 122 struct = mojom.Struct('test') | |
| 123 struct.AddField('testfield1', mojom.INT8) | |
| 124 struct.AddField('testfield3', mojom.UINT8, 3) | |
| 125 struct.AddField('testfield2', mojom.INT32, 2) | |
| 126 ps = pack.PackedStruct(struct) | |
| 127 errors += EXPECT_EQ(3, len(ps.packed_fields)) | |
| 128 | |
| 129 # Second byte should be packed in behind first, altering order. | |
| 130 errors += EXPECT_EQ('testfield1', ps.packed_fields[0].field.name) | |
| 131 errors += EXPECT_EQ('testfield3', ps.packed_fields[1].field.name) | |
| 132 errors += EXPECT_EQ('testfield2', ps.packed_fields[2].field.name) | |
| 133 | |
| 134 # Second byte should be packed with first. | |
| 135 errors += EXPECT_EQ(0, ps.packed_fields[0].offset) | |
| 136 errors += EXPECT_EQ(1, ps.packed_fields[1].offset) | |
| 137 errors += EXPECT_EQ(4, ps.packed_fields[2].offset) | |
| 138 | |
| 139 return errors | |
| 140 | |
| 141 | |
| 142 def TestBools(): | |
| 143 errors = 0 | |
| 144 struct = mojom.Struct('test') | |
| 145 struct.AddField('bit0', mojom.BOOL) | |
| 146 struct.AddField('bit1', mojom.BOOL) | |
| 147 struct.AddField('int', mojom.INT32) | |
| 148 struct.AddField('bit2', mojom.BOOL) | |
| 149 struct.AddField('bit3', mojom.BOOL) | |
| 150 struct.AddField('bit4', mojom.BOOL) | |
| 151 struct.AddField('bit5', mojom.BOOL) | |
| 152 struct.AddField('bit6', mojom.BOOL) | |
| 153 struct.AddField('bit7', mojom.BOOL) | |
| 154 struct.AddField('bit8', mojom.BOOL) | |
| 155 ps = pack.PackedStruct(struct) | |
| 156 errors += EXPECT_EQ(10, len(ps.packed_fields)) | |
| 157 | |
| 158 # First 8 bits packed together. | |
| 159 for i in xrange(8): | |
| 160 pf = ps.packed_fields[i] | |
| 161 errors += EXPECT_EQ(0, pf.offset) | |
| 162 errors += EXPECT_EQ("bit%d" % i, pf.field.name) | |
| 163 errors += EXPECT_EQ(i, pf.bit) | |
| 164 | |
| 165 # Ninth bit goes into second byte. | |
| 166 errors += EXPECT_EQ("bit8", ps.packed_fields[8].field.name) | |
| 167 errors += EXPECT_EQ(1, ps.packed_fields[8].offset) | |
| 168 errors += EXPECT_EQ(0, ps.packed_fields[8].bit) | |
| 169 | |
| 170 # int comes last. | |
| 171 errors += EXPECT_EQ("int", ps.packed_fields[9].field.name) | |
| 172 errors += EXPECT_EQ(4, ps.packed_fields[9].offset) | |
| 173 | |
| 174 return errors | |
| 175 | |
| 176 | |
| 177 def Main(args): | |
| 178 errors = 0 | |
| 179 errors += RunTest(TestZeroFields) | |
| 180 errors += RunTest(TestOneField) | |
| 181 errors += RunTest(TestPaddingPackedInOrder) | |
| 182 errors += RunTest(TestPaddingPackedOutOfOrder) | |
| 183 errors += RunTest(TestPaddingPackedOverflow) | |
| 184 errors += RunTest(TestNullableTypes) | |
| 185 errors += RunTest(TestAllTypes) | |
| 186 errors += RunTest(TestPaddingPackedOutOfOrderByOrdinal) | |
| 187 errors += RunTest(TestBools) | |
| 188 | |
| 189 return errors | |
| 190 | |
| 191 | |
| 192 if __name__ == '__main__': | |
| 193 sys.exit(Main(sys.argv[1:])) | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 814543006:
Move //mojo/{public, edk} underneath //third_party (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master