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)
def testFromStringChars(self):
name = Name.fromString("||")
self.assertEquals(Name(["||"]), name)
self.assertRaises(ValueError, Name.fromString, "||", isPackageName=True)
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"]
