third_party/WebKit/Source/build/scripts/make_token_matcher_unittest.py

   1 #!/usr/bin/env python
   2 # Copyright (C) 2013 Google Inc. 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 import tempfile
  31 import unittest
  32
  33 from make_token_matcher import BadInput, CaseLineProcessor, MainLineProcessor, Optimizer, process_file, SwitchCase, SwitchLineProcessor
  34
  35
  36 class OptimizerTest(unittest.TestCase):
  37     def test_nonalphabetic(self):
  38         optimizer = Optimizer(None, None, None)
  39         self.assertRaises(
  40             BadInput,
  41             optimizer.inspect_array,
  42             [SwitchCase('-', None), SwitchCase('x', None)],
  43             [0])
  44
  45
  46 class MainLineProcessorTest(unittest.TestCase):
  47     def test_switch(self):
  48         processor = MainLineProcessor(None)
  49         switchLineProcessor = processor.process_line('SWITCH(array, length) {')
  50         self.assertIsInstance(switchLineProcessor, SwitchLineProcessor)
  51         self.assertEquals('array', switchLineProcessor.array_variable)
  52         self.assertEquals('length', switchLineProcessor.length_variable)
  53
  54
  55 class SwitchLineProcessorTest(unittest.TestCase):
  56     def test_case(self):
  57         processor = SwitchLineProcessor(None, None, None, None)
  58         caseLineProcessor = processor.process_line('CASE("identifier") {')
  59         self.assertIsInstance(caseLineProcessor, CaseLineProcessor)
  60         self.assertEquals('identifier', caseLineProcessor.identifier)
  61
  62     def test_unexpected(self):
  63         processor = SwitchLineProcessor(None, None, None, None)
  64         self.assertRaises(
  65             BadInput,
  66             processor.process_line,
  67             'unexpected')
  68
  69     def test_repeated(self):
  70         processor = SwitchLineProcessor(None, None, None, None)
  71         processor.process_line('CASE("x") {').process_line('}')
  72         caseLineProcessor = processor.process_line('CASE("x") {')
  73         self.assertRaises(
  74             BadInput,
  75             caseLineProcessor.process_line,
  76             '}')
  77
  78
  79 class CaseLineProcessorTest(unittest.TestCase):
  80     def test_break(self):
  81         processor = CaseLineProcessor(None, None, None)
  82         self.assertRaises(
  83             BadInput,
  84             processor.process_line,
  85             'break;')
  86
  87
  88 class ProcessFileTest(unittest.TestCase):
  89     SOURCE_SMALL = """
  90         SWITCH(p, q) {
  91             CASE("a(") {
  92                 X;
  93             }
  94             CASE("b(") {
  95                 Y;
  96             }
  97         }
  98         """
  99
 100     EXPECTED_SMALL = """
 101         if (LIKELY(q == 2)) {
 102             if (LIKELY(p[1] == '(')) {
 103                 if ((p[0] | 0x20) == 'a') {
 104                     X;
 105                 } else if (LIKELY((p[0] | 0x20) == 'b')) {
 106                     Y;
 107                 }
 108             }
 109         }
 110         """
 111
 112     SOURCE_MEDIUM = """
 113         SWITCH (p, q) {
 114             CASE ("ab") {
 115                 X;
 116             }
 117             CASE ("cd") {
 118                 Y;
 119             }
 120             CASE ("ed") {
 121                 Z;
 122             }
 123         }
 124         """
 125
 126     EXPECTED_MEDIUM = """
 127         if (LIKELY(q == 2)) {
 128             if ((p[1] | 0x20) == 'b') {
 129                 if (LIKELY((p[0] | 0x20) == 'a')) {
 130                     X;
 131                 }
 132             } else if (LIKELY((p[1] | 0x20) == 'd')) {
 133                 if ((p[0] | 0x20) == 'c') {
 134                     Y;
 135                 } else if (LIKELY((p[0] | 0x20) == 'e')) {
 136                     Z;
 137                 }
 138             }
 139         }
 140         """
 141
 142     SOURCE_LARGE = """
 143         prefix;
 144         SWITCH(p, q) {
 145             CASE("hij") {
 146                 R;
 147             }
 148             CASE("efg") {
 149                 S;
 150             }
 151             CASE("c-") {
 152                 T;
 153             }
 154             CASE("klm") {
 155                 U;
 156             }
 157
 158             CASE("d-") {
 159                 V;
 160             }
 161             CASE("a") {
 162                 W;
 163                 X;
 164             }
 165             CASE("b-") {
 166                 Y;
 167                 Z;
 168             }
 169         }
 170         suffix;
 171         """
 172
 173     EXPECTED_LARGE = """
 174         prefix;
 175         switch (q) {
 176         case 1: {
 177             if (LIKELY((p[0] | 0x20) == 'a')) {
 178                 W;
 179                 X;
 180             }
 181         } break;
 182         case 2: {
 183             if (LIKELY(p[1] == '-')) {
 184                 switch ((p[0] | 0x20)) {
 185                 case 'b': {
 186                     Y;
 187                     Z;
 188                 } break;
 189                 case 'c': {
 190                     T;
 191                 } break;
 192                 case 'd': {
 193                     V;
 194                 } break;
 195                 }
 196             }
 197         } break;
 198         case 3: {
 199             switch ((p[0] | 0x20)) {
 200             case 'e': {
 201                 if (LIKELY((p[1] | 0x20) == 'f' && (p[2] | 0x20) == 'g')) {
 202                     S;
 203                 }
 204             } break;
 205             case 'h': {
 206                 if (LIKELY((p[1] | 0x20) == 'i' && (p[2] | 0x20) == 'j')) {
 207                     R;
 208                 }
 209             } break;
 210             case 'k': {
 211                 if (LIKELY((p[1] | 0x20) == 'l' && (p[2] | 0x20) == 'm')) {
 212                     U;
 213                 }
 214             } break;
 215             }
 216         } break;
 217         }
 218         suffix;
 219         """
 220
 221     def validate(self, source, expected):
 222         with tempfile.NamedTemporaryFile() as input_file:
 223             with tempfile.NamedTemporaryFile() as generated_file:
 224                 input_file.write(source)
 225                 input_file.flush()
 226                 process_file(input_file.name, generated_file.name)
 227                 # Our code generation does not yet implement pretty indentation.
 228                 actual = generated_file.read().replace('    ', '')
 229                 expected = expected.replace('    ', '')
 230                 self.assertEquals(actual, expected)
 231
 232     def test_small(self):
 233         self.validate(ProcessFileTest.SOURCE_SMALL, ProcessFileTest.EXPECTED_SMALL)
 234
 235     def test_medium(self):
 236         self.validate(ProcessFileTest.SOURCE_MEDIUM, ProcessFileTest.EXPECTED_MEDIUM)
 237
 238     def test_large(self):
 239         self.validate(ProcessFileTest.SOURCE_LARGE, ProcessFileTest.EXPECTED_LARGE)
 240
 241
 242 if __name__ == "__main__":
 243     unittest.main()