def testSubtypeClassWithParametersSelf(self): A = self.package.addClass(Name(["A"]), typeParameters=[], supertypes=[getRootClassType()]) T = self.package.addTypeParameter(A, Name(["T"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) S = self.package.addTypeParameter(None, Name(["S"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) X = self.package.addClass(Name(["X"]), typeParameters=[], supertypes=[getRootClassType()]) Y = self.package.addClass(Name(["Y"]), typeParameters=[], supertypes=[getRootClassType()]) ATty = ClassType(A, (VariableType(T), )) ASty = ClassType(A, (VariableType(S), )) AXty = ClassType(A, (ClassType(X), )) AYty = ClassType(A, (ClassType(Y), )) self.assertTrue(ATty.isSubtypeOf(ATty)) self.assertFalse(ATty.isSubtypeOf(ASty)) self.assertTrue(AXty.isSubtypeOf(AXty)) self.assertFalse(AXty.isSubtypeOf(AYty))
def testCaptureThis(self): source = "class C\n" + \ " def f =\n" + \ " def g = this" info = self.analyzeFromSource(source) cAst = info.ast.modules[0].definitions[0] C = info.package.findClass(name="C") CType = ClassType(C) f = info.package.findFunction(name="C.f") fScopeId = info.getScope(f).scopeId fContextInfo = info.getContextInfo(fScopeId) fContextClass = info.package.findClass(name=Name(["C", "f", CONTEXT_SUFFIX])) self.assertIs(fContextClass, fContextInfo.irContextClass) self.assertEquals(1, len(fContextClass.constructors)) self.assertEquals([self.makeField(Name(["C", "f", RECEIVER_SUFFIX]), type=CType, flags=frozenset([LET]))], fContextClass.fields) g = info.package.findFunction(name="C.f.g") gScopeId = info.getScope(g).scopeId gClosureInfo = info.getClosureInfo(gScopeId) gClosureClass = info.package.findClass(name=Name(["C", "f", "g", CLOSURE_SUFFIX])) self.assertIs(gClosureClass, gClosureInfo.irClosureClass) self.assertEquals({fScopeId: gClosureClass.fields[0]}, gClosureInfo.irClosureContexts) self.assertTrue(gClosureInfo.irClosureVar in f.variables) self.assertEquals(1, len(gClosureClass.constructors)) self.assertEquals([ClassType(gClosureClass), ClassType(fContextClass)], gClosureClass.constructors[0].parameterTypes) self.assertEquals([self.makeField(Name(["C", "f", "g", CLOSURE_SUFFIX, CONTEXT_SUFFIX]), type=ClassType(fContextClass))], gClosureClass.fields)
def testExistentialCombineParametersLub(self): # class C[S, T] # forsome [X, Y] C[X, Y] == forsome [X] C[X, String] lub forsome [Y] C[Object, Y] C = self.package.addClass(Name(["C"]), typeParameters=[], supertypes=[getRootClassType()]) S = self.package.addTypeParameter(C, Name(["S"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) T = self.package.addTypeParameter(C, Name(["T"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) X = self.package.addTypeParameter(None, Name(["X"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) XType = VariableType(X) eXType = ExistentialType((X, ), ClassType(C, (XType, getStringType()))) Y = self.package.addTypeParameter(None, Name(["Y"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) YType = VariableType(Y) eYType = ExistentialType((Y, ), ClassType(C, (getRootClassType(), YType))) eXYType = ExistentialType((X, Y), ClassType(C, (XType, YType))) self.assertEquals(eXYType, eXType.lub(eYType))
def setUp(self): super(TestExternalization, self).setUp() self.package = ir.Package(ids.TARGET_PACKAGE_ID) self.package.buildNameIndex() self.rootClassType = ir_types.getRootClassType() self.nothingClassType = ir_types.getNothingClassType() self.otherPackage = ir.Package() self.packageLoader = utils_test.FakePackageLoader([self.otherPackage]) self.info = CompileInfo(None, self.package, self.packageLoader) field = self.otherPackage.newField(Name(["x"]), type=ir_types.I64Type, flags=frozenset([PUBLIC])) self.clas = self.otherPackage.addClass(Name(["Foo"]), typeParameters=[], supertypes=[self.rootClassType], constructors=[], fields=[field], methods=[], flags=frozenset([PUBLIC])) self.classTy = ir_types.ClassType(self.clas) ctor = self.otherPackage.addFunction(Name([CONSTRUCTOR_SUFFIX]), returnType=ir_types.UnitType, typeParameters=[], parameterTypes=[], flags=frozenset([PUBLIC, METHOD])) self.clas.constructors = [ctor] method = self.otherPackage.addFunction(Name(["m"]), returnType=ir_types.UnitType, typeParameters=[], parameterTypes=[], flags=frozenset( [PUBLIC, METHOD])) self.clas.methods = [method] self.dep = self.package.ensureDependency(self.otherPackage)
def testRewriteNestedExistentialClassType(self): package = ir.Package(id=ids.TARGET_PACKAGE_ID) C = package.addClass(Name(["C"]), typeParameters=[], fields=[]) T = package.addTypeParameter(C, Name(["C", "T"]), upperBound=ir_types.getRootClassType(), lowerBound=ir_types.getNothingClassType(), flags=frozenset([STATIC])) X = package.addTypeParameter(None, Name(["X"]), upperBound=ir_types.VariableType(T), lowerBound=ir_types.getNothingClassType(), flags=frozenset([STATIC]), index=1) Y = package.addTypeParameter(None, Name(["Y"]), upperBound=ir_types.VariableType(X), lowerBound=ir_types.getNothingClassType(), flags=frozenset([STATIC]), index=2) package.buildNameIndex() self.des.typeParameters = [T] ty = ir_types.ExistentialType( [X], ir_types.ExistentialType( [Y], ir_types.ClassType(C, (ir_types.VariableType(Y),)))) self.checkType(ty, package)
def testImportRedeclare(self): foo = Package(name=Name(["foo"])) foo.addGlobal(Name(["bar"]), None, None, frozenset([PUBLIC, LET])) source = "let bar = 12\n" + \ "import foo.bar" self.assertRaises(ScopeException, self.analyzeFromSource, source, packageLoader=FakePackageLoader([foo]))
def testJointExistentials(self): Foo = self.package.addClass(Name(["Foo"]), typeParameters=[], supertypes=[getRootClassType()]) S = self.package.addTypeParameter(Foo, Name(["S"]), upperBound=getRootClassType(), lowerBound=getNothingClassType(), flags=frozenset([STATIC, COVARIANT])) T = self.package.addTypeParameter(Foo, Name(["T"]), upperBound=getRootClassType(), lowerBound=getNothingClassType(), flags=frozenset([STATIC, COVARIANT])) X = self.package.addTypeParameter(None, Name(["X"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) Y = self.package.addTypeParameter(None, Name(["Y"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) eX = ExistentialType( (X, ), ClassType(Foo, (VariableType(X), getNothingClassType()))) eY = ExistentialType( (Y, ), ClassType(Foo, (getNothingClassType(), VariableType(Y)))) expected = ExistentialType( (X, Y), ClassType(Foo, (VariableType(X), VariableType(Y)))) self.assertTrue(expected.isEquivalent(eX.lub(eY)))
def count_unique_names(bill_first_name, bill_last_name, ship_first_name, ship_last_name, bill_name_on_card): nickname_finder = NameDenormalizer( r"D:\developnemt\UniqueNameCounter\names.csv") bill_name = Name.from_first_and_last(bill_first_name, bill_last_name, nickname_finder) ship_name = Name.from_first_and_last(ship_first_name, ship_last_name, nickname_finder) card_name = Name.from_str(bill_name_on_card, nickname_finder) bill_to_ship = bill_name == ship_name ship_to_card = ship_name == card_name bill_to_card = bill_name == card_name if bill_to_ship: if ship_to_card or bill_to_card: return ALL_THE_SAME else: return ONE_IS_DIFFERENT if ship_to_card: if bill_to_card: return ALL_THE_SAME else: return ONE_IS_DIFFERENT if bill_to_card: return ONE_IS_DIFFERENT return ALL_ARE_DIFFERENT
def testRewriteTraitTypeWithArgs(self): package = ir.Package(id=ids.TARGET_PACKAGE_ID) Tr = package.addTrait(Name(["Tr"]), typeParameters=[]) S = package.addTypeParameter(Tr, Name(["Tr", "S"])) T = package.addTypeParameter(Tr, Name(["Tr", "T"])) self.des.typeParameters = [S, T] self.checkType(ir_types.ClassType.forReceiver(Tr), package)
def testFromStringChars(self): name = Name.fromString("||") self.assertEquals(Name(["||"]), name) self.assertRaises(ValueError, Name.fromString, "||", isPackageName=True)
def testRewriteClassTypeWithArgs(self): package = ir.Package(id=ids.TARGET_PACKAGE_ID) C = package.addClass(Name(["C"]), typeParameters=[]) S = package.addTypeParameter(C, Name(["C", "S"])) T = package.addTypeParameter(C, Name(["C", "T"])) self.des.typeParameters = [S, T] self.checkType(ir_types.ClassType.forReceiver(C), package)
def testExternalizeCyclicTypeParameters(self): S = self.package.addTypeParameter( None, Name(["S"]), upperBound=ir_types.getRootClassType()) T = self.package.addTypeParameter(None, Name(["T"]), upperBound=ir_types.VariableType(S)) S.lowerBound = ir_types.VariableType(T) externalizeTypeParameter(self.info, S)
def p_single_type_name_list(p): '''single_type_name_list : name_list DASH type''' result = [] for name in p[1]: new_name = Name(name.name) new_name.type = p[3] result.append(new_name) p[0] = result
def p_name_list(p): '''name_list : name_list ID | ID''' if len(p) == 2: p[0] = [Name(p[1])] else: p[1].append(Name(p[2])) p[0] = p[1]
def testTypeParameterIndices(self): source = "class Foo[static A]\n" + \ " def m[static B](x: forsome [C] forsome [D] D) = ()" info = self.analyzeFromSource(source) A = info.package.findTypeParameter(name="Foo.A") B = info.package.findTypeParameter(name="Foo.m.B") C = info.package.findTypeParameter(name=Name(["Foo", "m", EXISTENTIAL_SUFFIX, "C"])) D = info.package.findTypeParameter(name=Name(["Foo", "m", EXISTENTIAL_SUFFIX, EXISTENTIAL_SUFFIX, "D"])) self.assertEquals([0, 1, 2, 3], [p.index for p in [A, B, C, D]])
def testTypeParameterCycleForeign(self): package = Package(name=Name(["foo"])) barClass = package.addClass(Name(["Bar"]), sourceName="Bar", typeParameters=[], supertypes=[getRootClassType()], constructors=[], fields=[], methods=[], flags=frozenset([PUBLIC])) loader = FakePackageLoader([package]) source = "class Baz <: foo.Bar\n" + \ "def f[static T <: Baz >: foo.Bar] = ()" self.assertRaises(InheritanceException, self.analyzeFromSource, source, packageLoader=loader)
def testSubtypeParametersNonOverlapping(self): T = self.package.addTypeParameter(None, Name(["T"]), upperBound=ClassType(self.A), lowerBound=ClassType(self.B)) S = self.package.addTypeParameter(None, Name(["S"]), upperBound=ClassType(self.B), lowerBound=ClassType(self.C)) self.assertTrue(VariableType(S).isSubtypeOf(VariableType(T)))
def runTest(self): names = [ ('a_simple_case', '_', ['a', 'simple', 'case']), ('a__slightly_more_complicated_case', '_', ['a', '', 'slightly', 'more', 'complicated', 'case']), ('_a_', '_', ['', 'a', '']), ] for name, delim, expectedTokens in names: asName = Name(name, delim) assert asName.split() == expectedTokens assert asName.up() == delim.join(expectedTokens[:-1]) assert asName.up(2) == delim.join(expectedTokens[:-2]) for n, tok in enumerate(expectedTokens): assert asName[n] == tok camelNames = [ ('thisIsCamel', '_', ['this', 'Is', 'Camel']), ('ThisHasLOTSOFCaps', '_', ['This', 'Has', 'LOTSOFCaps']), ('SomeNumbers123In_thisOne456', '_', ['Some', 'Numbers', '123', 'In', 'this', 'One', '456']), ] for name, delim, expectedTokens in camelNames: asName = CamelCaseName(name) assert len(asName) == len(expectedTokens) assert asName.split() == expectedTokens assert asName.up() == ''.join(expectedTokens[:-1]) assert asName.up(2) == ''.join(expectedTokens[:-2]) for n, tok in enumerate(expectedTokens): assert asName[n] == tok
def testDefineClassVarWithLocals(self): source = "class C()\n" + \ " var x =\n" + \ " var y = 12\n" + \ " y" info = self.analyzeFromSource(source) irInitializer = info.package.findClass(name="C").initializer self.assertEquals([self.makeVariable(Name(["C", CLASS_INIT_SUFFIX, RECEIVER_SUFFIX]), kind=PARAMETER, flags=frozenset([LET])), self.makeVariable(Name(["C", LOCAL_SUFFIX, "y"]), kind=LOCAL)], irInitializer.variables)
def testExternalizeGlobal(self): globl = self.otherPackage.addGlobal(Name(["g"]), type=self.classTy, flags=frozenset([PUBLIC])) externGlobal = externalizeDefn(self.info, globl) expected = self.makeGlobal(Name(["g"]), id=globl.id, type=self.classTy, flags=frozenset([PUBLIC, EXTERN])) self.assertEquals(expected, externGlobal) self.checkExternPosition(externGlobal)
def testLubSubTrait(self): A = self.package.addTrait(Name(["A"]), typeParameters=[], supertypes=[getRootClassType()]) ATy = ClassType(A) B = self.package.addTrait(Name(["B"]), typeParameters=[], supertypes=[ATy, getRootClassType()]) BTy = ClassType(B) self.assertEquals(ATy, ATy.lub(BTy)) self.assertEquals(ATy, BTy.lub(ATy))
def testMangleFunctionNameSimple(self): package = ir.Package(ids.TARGET_PACKAGE_ID) f = self.makeFunction(Name(["foo", "bar", "baz"]), returnType=UnitType, typeParameters=[], parameterTypes=[ UnitType, BooleanType, I8Type, I16Type, I32Type, I64Type, F32Type, F64Type ]) expected = Name(["foo", "bar", "baz(U,Z,B,S,I,L,F,D)"]) self.assertEquals(expected, ir.mangleFunctionName(f, package))
def testExistentialDifferentBoundsNotEquivalent(self): X = self.package.addTypeParameter(None, Name(["X"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) Y = self.package.addTypeParameter(None, Name(["Y"]), upperBound=getStringType(), lowerBound=getNothingClassType()) eXType = ExistentialType((X, ), VariableType(X)) eYType = ExistentialType((Y, ), VariableType(Y)) self.assertFalse(eXType.isEquivalent(eYType))
def test_write_file(self): actual = ['Janet Parsons\n','Vaughn Lewis\n','Adonis Julius Archer\n','Shelby Nathan Yoder\n'] nameList = [] nameList.append(Name('Janet Parsons\n')) nameList.append(Name('Vaughn Lewis\n')) nameList.append(Name('Adonis Julius Archer\n')) nameList.append(Name('Shelby Nathan Yoder\n')) fileName = 'test_write.txt' FileWrite(fileName).write(nameList) with open(fileName, "r") as f: expect = f.readlines() self.assertEqual(actual, expect)
def test_name_length(): short_and_long_words = [ "sweaterdresses", # trigger "bob", "incomprehensibilities", # trigger "croissants", "otorhinolaryngological", # trigger ] name = Name() for word in short_and_long_words: assert name.verify_name(word) == True, "name shouldn't be too long!"
def testEffectiveClassTypeForVariableType(self): aTy = ClassType(self.A) S = self.package.addTypeParameter(None, Name(["S"]), upperBound=aTy, lowerBound=getNothingClassType()) sTy = VariableType(S) T = self.package.addTypeParameter(None, Name(["T"]), upperBound=sTy, lowerBound=getNothingClassType()) tTy = VariableType(T) self.assertEquals((aTy, []), tTy.effectiveClassType())
def testInheritFromImportedClass(self): foo = Package(name=Name(["foo"])) Bar = foo.addClass(Name(["Bar"]), sourceName="Bar", typeParameters=[], supertypes=[getRootClassType()], constructors=[], fields=[], methods=[], flags=frozenset([PUBLIC])) x = foo.newField(Name(["Bar", "x"]), sourceName="x", flags=frozenset([PUBLIC, LET])) Bar.fields.append(x) source = "import foo.Bar\n" + \ "class Baz <: Bar" info = self.analyzeFromSource(source, packageLoader=FakePackageLoader([foo])) bazScope = info.getScope(info.ast.modules[0].definitions[1]) self.assertTrue(bazScope.isBound("x"))
def test_name_clean(): illegal_words = [ "gadzooks", # trigger "barnacles", "William Shatner", "cowabunga", "zoinks", # trigger "crikey", # trigger ] name = Name() for word in illegal_words: assert name.is_clean(name) == True, "name shouldn't contain profanity!"
def runTest(self): names = [ ("a_simple_case", "_", ["a", "simple", "case"]), ("a__slightly_more_complicated_case", "_", ["a", "", "slightly", "more", "complicated", "case"]), ("_a_", "_", ["", "a", ""]), ] for name, delim, expectedTokens in names: asName = Name(name, delim) assert asName.split() == expectedTokens assert asName.up() == delim.join(expectedTokens[:-1]) assert asName.up(2) == delim.join(expectedTokens[:-2]) for n, tok in enumerate(expectedTokens): assert asName[n] == tok camelNames = [ ("thisIsCamel", "_", ["this", "Is", "Camel"]), ("ThisHasLOTSOFCaps", "_", ["This", "Has", "LOTSOFCaps"]), ("SomeNumbers123In_thisOne456", "_", ["Some", "Numbers", "123", "In", "this", "One", "456"]), ] for name, delim, expectedTokens in camelNames: asName = CamelCaseName(name) assert len(asName) == len(expectedTokens) assert asName.split() == expectedTokens assert asName.up() == "".join(expectedTokens[:-1]) assert asName.up(2) == "".join(expectedTokens[:-2]) for n, tok in enumerate(expectedTokens): assert asName[n] == tok
def testSubtypeParametersTransitiveUpper(self): U = self.package.addTypeParameter(None, Name(["U"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) T = self.package.addTypeParameter(None, Name(["T"]), upperBound=VariableType(U), lowerBound=getNothingClassType()) S = self.package.addTypeParameter(None, Name(["S"]), upperBound=VariableType(T), lowerBound=getNothingClassType()) self.assertTrue(VariableType(S).isSubtypeOf(VariableType(U)))
def testEffectiveClassTypeForExistentialType(self): S = self.package.addTypeParameter(None, Name(["S"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) sTy = VariableType(S) T = self.package.addTypeParameter(None, Name(["T"]), upperBound=getRootClassType(), lowerBound=getNothingClassType()) tTy = VariableType(T) pTy = ClassType(self.P, (sTy, tTy)) eTy = ExistentialType([S], ExistentialType([T], pTy)) self.assertEquals((pTy, [S, T]), eTy.effectiveClassType())
def infoAndScopeWithPackageNames(self, args): packageNameFromString = lambda s: Name.fromString(s, isPackageName=True) names = map(packageNameFromString, args) package = Package(id=TARGET_PACKAGE_ID) packageLoader = FakePackageLoader(names) info = CompileInfo(None, package, packageLoader) scope = PackageScope(PACKAGE_SCOPE_ID, None, info, names, [], None) return info, scope
def testFunctionTypeParameterStatic(self): source = "def f[static T] = ()" info = self.analyzeFromSource(source) T = info.package.findTypeParameter(name="f.T") self.assertEquals(Name.fromString("f.T"), T.name) self.assertEquals(frozenset([STATIC]), T.flags) f = info.package.findFunction(name="f") self.assertEquals(1, len(f.typeParameters)) self.assertIs(T, f.typeParameters[0]) self.assertEquals(0, T.index)
def __init__(self, director, background_name): ''' Constructor ''' Scene.__init__(self, director, background_name) self.name = Name() self.scene_winner = Sce_Winner(director, 'winner', NAME_SCENE) self.c_fails = 0 self.name.generate_table() for buttom in self.common_buttoms.itervalues(): buttom.is_visible = True
def convertItem(self, item, field = 'name'): name = item[field] url = item['url'] des = item['description'] _name = Name(name) _name.url = url _name.volume = item['volume'] _name.brand = item['brand'] _name.cat = item['category'] _name.url = url _name.des = des return _name
def name(self, name): if Name.isValid(name): self._name = Name.format(name)
def testUnicodeShortReturnsStr(self): name = Name([unicode("foo")]) self.assertEquals(str, type(name.short()))
def testFromStringBasic(self): name = Name.fromString("foo") self.assertEquals(Name(["foo"]), name) name = Name.fromString("foo.bar.baz") self.assertEquals(Name(["foo", "bar", "baz"]), name)
class Sce_Name(Scene): ''' classdocs ''' def __init__(self, director, background_name): ''' Constructor ''' Scene.__init__(self, director, background_name) self.name = Name() self.scene_winner = Sce_Winner(director, 'winner', NAME_SCENE) self.c_fails = 0 self.name.generate_table() for buttom in self.common_buttoms.itervalues(): buttom.is_visible = True def on_update(self): self.time = self.director.time if not self.is_failed: self.update() for key, option in self.name.options_names.iteritems(): if option.is_release: if option.rect.colliderect(self.name.text_field_rect): if key == self.name.current_exercise_key: option.move(self.name.text_field_rect.center) option.is_correct = True else: self.c_fails += 1 if self.c_fails >= 2: self.c_fails = 0 self.is_failed = True option.move_to_firts_pos() else: option.move_to_firts_pos() if option.is_pressed: if not option.is_correct: option.move(pygame.mouse.get_pos()) self.is_complete = self.name.check_complete() def on_event(self, event): self.event(event) if event.type == pygame.MOUSEBUTTONDOWN: mouse_pos = pygame.mouse.get_pos() for option in self.name.options_names.itervalues(): option.pressed(mouse_pos) elif event.type == pygame.MOUSEBUTTONUP: for option in self.name.options_names.itervalues(): option.release() def on_draw(self, screen): self.draw(screen) self.name.draw(screen) if self.is_failed: screen.blit(self.failed_img, self.failed_rect)
def __init__(self): Name.__init__(self) self.email_suffixes = self.get_file_data("email_suffixes.txt") self.free_email_suffixes = ["@gmail.com", "@yahoo.com", "@aol.com", "@hotmail.com"]