mirror of
https://github.com/cappuccino/cappuccino.git
synced 2026-08-25 21:17:03 +00:00
508 lines
18 KiB
Plaintext
508 lines
18 KiB
Plaintext
@import <AppKit/CGAffineTransform.j>
|
|
@import "CGTestCase.j"
|
|
|
|
@implementation CGAffineTransformTest : CGTestCase
|
|
|
|
- (void)testAffineTransformMake
|
|
{
|
|
[self compareTransform:CGAffineTransformMake(1, 2, 3, 4, 3.2, 5.4)
|
|
with:{ a: 1, b: 2, c: 3, d: 4, tx: 3.2, ty: 5.4 }
|
|
message:"transform make"];
|
|
}
|
|
|
|
- (void)testCGAffineTransformMakeIdentity
|
|
{
|
|
[self compareTransform:CGAffineTransformMakeIdentity()
|
|
with:{ a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 }
|
|
message:"transform make identity"];
|
|
}
|
|
|
|
- (void)testAffineTransformMakeCopy
|
|
{
|
|
var transform = CGAffineTransformMake(1, 2, 3, 4, 3.2, 5.4),
|
|
t2 = CGAffineTransformMakeCopy(transform);
|
|
|
|
transform.a = transform.b = transform.c = transform.d =
|
|
transform.tx = transform.ty = 0;
|
|
|
|
[self compareTransform:t2
|
|
with:CGAffineTransformMake(1, 2, 3, 4, 3.2, 5.4)
|
|
message:"copy correctly made"];
|
|
|
|
[self compareTransform:transform
|
|
with:CGAffineTransformMake(0, 0, 0, 0, 0, 0)
|
|
message:"original transform was changed"];
|
|
}
|
|
|
|
- (void)testAffineTransformCreateCopy
|
|
{
|
|
// FIXME: CGAffineTransformCreateCopy seems to be working but code has a Fixme?
|
|
var transform = CGAffineTransformMake(1, 2, 3, 4, 3.2, 5.4),
|
|
t2 = CGAffineTransformCreateCopy(transform);
|
|
|
|
transform.a = transform.b = transform.c = transform.d =
|
|
transform.tx = transform.ty = 0;
|
|
|
|
[self compareTransform:t2
|
|
with:CGAffineTransformMake(1, 2, 3, 4, 3.2, 5.4)
|
|
message:"copy correctly made"];
|
|
|
|
[self compareTransform:transform
|
|
with:CGAffineTransformMake(0, 0, 0, 0, 0, 0)
|
|
message:"original transform was changed"] ;
|
|
}
|
|
|
|
- (void)testAffineTransformMakeScale
|
|
{
|
|
[self compareTransform:CGAffineTransformMakeScale(3, 4)
|
|
with:CGAffineTransformMake(3, 0, 0, 4, 0, 0)
|
|
message:"make scale"];
|
|
}
|
|
|
|
- (void)testAffineTransformMakeTranslation
|
|
{
|
|
[self compareTransform:CGAffineTransformMakeTranslation(3, 4)
|
|
with:CGAffineTransformMake(1, 0, 0, 1, 3, 4)
|
|
message:"make translation"];
|
|
}
|
|
|
|
- (void)testAffineTransformTranslate
|
|
{
|
|
var transform = CGAffineTransformMakeTranslation(3, 4);
|
|
|
|
[self compareTransform:CGAffineTransformTranslate(transform, -3, -4)
|
|
with:CGAffineTransformMakeIdentity()
|
|
message:"translate to identity"];
|
|
|
|
[self compareTransform:CGAffineTransformTranslate(transform, 0, 0)
|
|
with:transform
|
|
message:"zero translate"];
|
|
}
|
|
|
|
- (void)testAffineTransformScale
|
|
{
|
|
var transform = CGAffineTransformMakeScale(3, 4);
|
|
|
|
[self compareTransform:CGAffineTransformScale(transform, 1 / 3, 1 / 4)
|
|
with:CGAffineTransformMakeIdentity()
|
|
message:"scale to identity"];
|
|
|
|
transform = CGAffineTransformMake(2, -2, -3, 3, 3.2, 5.4);
|
|
[self compareTransform:CGAffineTransformScale(transform, 1, 1)
|
|
with:transform
|
|
message:"scale by 1"];
|
|
|
|
[self compareTransform:CGAffineTransformScale(transform, 2, 5)
|
|
with:CGAffineTransformMake(4,-4,-15,15, 3.2,5.4)
|
|
message:"random scale to somewhere"];
|
|
}
|
|
|
|
- (void)testAffineTransformConcat
|
|
{
|
|
var testcases = {
|
|
"identity concat" : {
|
|
testdata: CGAffineTransformConcat(CGAffineTransformMakeIdentity(),
|
|
CGAffineTransformMakeIdentity()),
|
|
expdata: CGAffineTransformMakeIdentity()
|
|
},
|
|
|
|
"translation" : {
|
|
testdata: CGAffineTransformConcat(CGAffineTransformMakeTranslation(3, 4),
|
|
CGAffineTransformMakeTranslation(-3, -4)),
|
|
expdata: CGAffineTransformMakeIdentity()
|
|
},
|
|
|
|
"translation (reversed)" : {
|
|
testdata: CGAffineTransformConcat(CGAffineTransformMakeTranslation(-3, -4),
|
|
CGAffineTransformMakeTranslation(3, 4)),
|
|
expdata: CGAffineTransformMakeIdentity()
|
|
},
|
|
|
|
"scale" : {
|
|
testdata: CGAffineTransformConcat(CGAffineTransformMakeScale(3, 4),
|
|
CGAffineTransformMakeScale(1 / 3, 1 / 4)),
|
|
expdata: CGAffineTransformMakeIdentity()
|
|
},
|
|
|
|
"scale (reversed)" : {
|
|
testdata: CGAffineTransformConcat(CGAffineTransformMakeScale(1 / 3, 1 / 4),
|
|
CGAffineTransformMakeScale(3, 4)),
|
|
expdata: CGAffineTransformMakeIdentity()
|
|
},
|
|
|
|
"rotation" : {
|
|
testdata: CGAffineTransformConcat(CGAffineTransformMakeRotation(PI),
|
|
CGAffineTransformMakeRotation(-PI)),
|
|
expdata: CGAffineTransformMakeIdentity()
|
|
},
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self compareTransform:testcases[key].testdata with:testcases[key].expdata message:key];
|
|
}
|
|
|
|
- (void)testPointApplyAffineTransform
|
|
{
|
|
var testcases = {
|
|
"translate to zero" : {
|
|
testdata: CGPointApplyAffineTransform(CGPointMake(3, 4),
|
|
CGAffineTransformMakeTranslation(-3, -4)),
|
|
expdata: CGPointMakeZero()
|
|
},
|
|
|
|
"scale to 1,1" : {
|
|
testdata: CGPointApplyAffineTransform(CGPointMake(3, 4),
|
|
CGAffineTransformMakeScale(1 / 3, 1 / 4)),
|
|
expdata: CGPointMake(1, 1)
|
|
},
|
|
|
|
"scale and translate to zero" : {
|
|
testdata: CGPointApplyAffineTransform(CGPointMake(3, 4),
|
|
CGAffineTransformConcat(
|
|
CGAffineTransformMakeScale(1 / 3, 1 / 4),
|
|
CGAffineTransformMakeTranslation(-1, -1))),
|
|
expdata: CGPointMakeZero()
|
|
},
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self comparePoint:testcases[key].testdata with:testcases[key].expdata message:key];
|
|
}
|
|
|
|
- (void)testSizeApplyAffineTransform
|
|
{
|
|
var testcases = {
|
|
"translation on size should do nothing" : {
|
|
testdata: CGSizeApplyAffineTransform(CGSizeMake(3, 12),
|
|
CGAffineTransformMakeTranslation(-3, -4)),
|
|
expdata: CGSizeMake(3, 12)
|
|
},
|
|
|
|
"scale to 1,1" : {
|
|
testdata: CGSizeApplyAffineTransform(CGSizeMake(3, 4),
|
|
CGAffineTransformMakeScale(1 / 3, 1 / 4) ),
|
|
expdata: CGSizeMake(1, 1)
|
|
},
|
|
|
|
"scale and translate combined" : {
|
|
testdata: CGSizeApplyAffineTransform(CGSizeMake(3, 4),
|
|
CGAffineTransformConcat(
|
|
CGAffineTransformMakeScale(1 / 3, 1 / 4),
|
|
CGAffineTransformMakeTranslation(-1, -1))),
|
|
expdata: CGSizeMake(1, 1)
|
|
|
|
},
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self compareSize:testcases[key].testdata with:testcases[key].expdata message:key];
|
|
}
|
|
|
|
- (void)testAffineTransformIsIdentityPositive
|
|
{
|
|
var testcases = {
|
|
"identity is identity" : {
|
|
testdata: CGAffineTransformMakeIdentity()
|
|
},
|
|
|
|
"zero rotation is identity" : {
|
|
testdata: CGAffineTransformMakeRotation(0),
|
|
},
|
|
|
|
"zero translation is identity" : {
|
|
testdata: CGAffineTransformMakeTranslation(0,0)
|
|
},
|
|
|
|
"one scale is identity" : {
|
|
testdata: CGAffineTransformMakeScale(1, 1)
|
|
},
|
|
|
|
"identity concat'ed" : {
|
|
testdata: CGAffineTransformConcat(CGAffineTransformMakeIdentity(),
|
|
CGAffineTransformMakeIdentity()),
|
|
},
|
|
|
|
"translation" : {
|
|
testdata: CGAffineTransformConcat(CGAffineTransformMakeTranslation(3, 4),
|
|
CGAffineTransformMakeTranslation(-3, -4)),
|
|
},
|
|
|
|
"scale" : {
|
|
testdata: CGAffineTransformConcat(CGAffineTransformMakeScale(3, 4),
|
|
CGAffineTransformMakeScale(1 / 3, 1 / 4)),
|
|
},
|
|
|
|
"rotation" : {
|
|
testdata: CGAffineTransformConcat(CGAffineTransformMakeRotation(-PI),
|
|
CGAffineTransformMakeRotation(PI)),
|
|
},
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self assert:YES
|
|
equals:CGAffineTransformIsIdentity(testcases[key].testdata)
|
|
message:key];
|
|
}
|
|
|
|
- (void)testAffineTransformIsIdentityNegative
|
|
{
|
|
var testcases = {
|
|
"some random transform" : {
|
|
testdata: CGAffineTransformMake(1, 1, 1, 1, 1, 1)
|
|
},
|
|
|
|
"non-zero translation is not identity" : {
|
|
testdata: CGAffineTransformMakeTranslation(1, 1)
|
|
},
|
|
|
|
"non-one scale is not identity" : {
|
|
testdata: CGAffineTransformMakeScale(2,2)
|
|
},
|
|
|
|
"rotation" : {
|
|
testdata: CGAffineTransformMakeRotation(PI),
|
|
},
|
|
|
|
// TODO a two-pi rotation is actually identity
|
|
"2PI rotation is NOT identity?" : {
|
|
testdata: CGAffineTransformMakeRotation(PI * 2),
|
|
},
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self assert:NO
|
|
equals:CGAffineTransformIsIdentity(testcases[key].testdata)
|
|
message:key];
|
|
}
|
|
|
|
- (void)testAffineTransformEqualToTransform
|
|
{
|
|
var testcases = {
|
|
"identity" : {
|
|
lhs: CGAffineTransformMakeIdentity(),
|
|
rhs: CGAffineTransformMakeIdentity(),
|
|
expdata: YES
|
|
},
|
|
|
|
"translate" : {
|
|
lhs: CGAffineTransformMakeTranslation(1, 1),
|
|
rhs: CGAffineTransformMakeTranslation(1, 1),
|
|
expdata: YES
|
|
},
|
|
|
|
"scale" : {
|
|
lhs: CGAffineTransformMakeScale(1, 1),
|
|
rhs: CGAffineTransformMakeScale(1, 1),
|
|
expdata: YES
|
|
},
|
|
|
|
"rotation" : {
|
|
lhs: CGAffineTransformMakeRotation(PI),
|
|
rhs: CGAffineTransformMakeRotation(PI),
|
|
expdata: YES
|
|
},
|
|
|
|
"translate and scale" : {
|
|
lhs: CGAffineTransformMakeScale(1, 1),
|
|
rhs: CGAffineTransformMakeTranslation(1, 1),
|
|
expdata: NO
|
|
},
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self assert:testcases[key].expdata
|
|
equals:CGAffineTransformEqualToTransform(testcases[key].lhs, testcases[key].rhs)
|
|
message:key];
|
|
}
|
|
|
|
- (void)testStringCreateWithCGAffineTransform
|
|
{
|
|
// FIXME?: should there be a leading space on these strings
|
|
var testcases = {
|
|
"identity" : {
|
|
testdata: CGAffineTransformMakeIdentity(),
|
|
expdata: " [[ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1]]"
|
|
},
|
|
|
|
"scale" : {
|
|
testdata: CGAffineTransformMakeScale(3, 4),
|
|
expdata: " [[ 3, 0, 0 ], [ 0, 4, 0 ], [ 0, 0, 1]]"
|
|
},
|
|
|
|
"translation" : {
|
|
testdata: CGAffineTransformMakeTranslation(3, 4),
|
|
expdata: " [[ 1, 0, 0 ], [ 0, 1, 0 ], [ 3, 4, 1]]"
|
|
},
|
|
|
|
"scale and translation" : {
|
|
testdata: CGAffineTransformTranslate(CGAffineTransformMakeScale(3, 4), 5, 6),
|
|
expdata: " [[ 3, 0, 0 ], [ 0, 4, 0 ], [ 15, 24, 1]]"
|
|
},
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self assert:testcases[key].expdata
|
|
equals:CGStringCreateWithCGAffineTransform(testcases[key].testdata)
|
|
message:key];
|
|
}
|
|
|
|
- (void)testStringFromCGAffineTransform
|
|
{
|
|
var testcases = {
|
|
"identity" : {
|
|
testdata: CGAffineTransformMakeIdentity(),
|
|
expdata: "{1, 0, 0, 1, 0, 0}"
|
|
},
|
|
|
|
"scale" : {
|
|
testdata: CGAffineTransformMakeScale(3, 4),
|
|
expdata: "{3, 0, 0, 4, 0, 0}"
|
|
},
|
|
|
|
"translation" : {
|
|
testdata: CGAffineTransformMakeTranslation(3, 4),
|
|
expdata: "{1, 0, 0, 1, 3, 4}"
|
|
},
|
|
|
|
"rotation - zero" : {
|
|
testdata: CGAffineTransformMakeRotation(0),
|
|
expdata: "{1, 0, 0, 1, 0, 0}"
|
|
},
|
|
|
|
"rotation - pi" : {
|
|
testdata: CGAffineTransformMakeRotation(PI),
|
|
expdata: "{-1, 1.2246467991473532e-16, -1.2246467991473532e-16, -1, 0, 0}"
|
|
},
|
|
|
|
"rotation - 2pi" : {
|
|
testdata: CGAffineTransformMakeRotation(2 * PI),
|
|
expdata: "{1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 0, 0}"
|
|
},
|
|
|
|
"rotation - 3pi" : {
|
|
testdata: CGAffineTransformMakeRotation(3 * PI),
|
|
expdata: "{-1, 3.6739403974420594e-16, -3.6739403974420594e-16, -1, 0, 0}"
|
|
},
|
|
|
|
"scale and translation and rotate" : {
|
|
testdata: CGAffineTransformRotate(CGAffineTransformTranslate(CGAffineTransformMakeScale(3, 4), 5, 6), PI),
|
|
expdata: "{-3, 4.898587196589413e-16, -3.6739403974420594e-16, -4, 15, 24}"
|
|
},
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self assert:testcases[key].expdata
|
|
equals:CPStringFromCGAffineTransform(testcases[key].testdata)
|
|
message:key];
|
|
}
|
|
|
|
- (void)testAffineTransformRotate
|
|
{
|
|
var ang = PI + 0.5 * PI,
|
|
transform = CGAffineTransformMake(1, 2, 3, 4, 5, 6),
|
|
cos = COS(ang),
|
|
sin = SIN(ang);
|
|
|
|
var testcases = {
|
|
"affine transform rotate failed" : {
|
|
testdata: CGAffineTransformRotate(transform, ang),
|
|
expdata: CGAffineTransformMake(transform.a * cos + transform.c * sin,
|
|
transform.b * cos + transform.d * sin,
|
|
transform.c * cos - transform.a * sin,
|
|
transform.d * cos - transform.b * sin,
|
|
transform.tx,transform.ty)
|
|
},
|
|
|
|
"rotation negation" : {
|
|
testdata: CGAffineTransformRotate(CGAffineTransformRotate(CGAffineTransformMakeScale(3, 4), PI), -PI),
|
|
expdata: CGAffineTransformMakeScale(3, 4)
|
|
}
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self compareTransform:testcases[key].testdata with:testcases[key].expdata message:key];
|
|
}
|
|
|
|
- (void)testAffineTransformInvert
|
|
{
|
|
var transform = CGAffineTransformRotate(CGAffineTransformTranslate(CGAffineTransformMakeScale(3, 4), 5, 6), PI),
|
|
determinant = 1 / (transform.a * transform.d - transform.b * transform.c),
|
|
invertedtransform = CGAffineTransformMake(determinant * transform.d,
|
|
-determinant * transform.b,
|
|
-determinant * transform.c,
|
|
determinant * transform.a,
|
|
determinant * (transform.c * transform.ty -
|
|
transform.d * transform.tx),
|
|
determinant * (transform.b * transform.tx -
|
|
transform.a * transform.ty));
|
|
|
|
var testcases = {
|
|
"test invert algorithm" : {
|
|
testdata: transform,
|
|
expdata: invertedtransform
|
|
},
|
|
|
|
"identity should be it self on inversion" : {
|
|
testdata: CGAffineTransformMakeIdentity(),
|
|
expdata: CGAffineTransformMakeIdentity()
|
|
},
|
|
|
|
"rotation" : {
|
|
testdata: CGAffineTransformMakeRotation(-PI),
|
|
expdata: CGAffineTransformMakeRotation(PI),
|
|
},
|
|
|
|
"translation" : {
|
|
testdata: CGAffineTransformMakeTranslation(4, 5),
|
|
expdata: CGAffineTransformMakeTranslation(-4, -5)
|
|
},
|
|
|
|
"scale" : {
|
|
testdata: CGAffineTransformMakeScale(3, 4),
|
|
expdata: CGAffineTransformMakeScale(1 / 3, 1 / 4)
|
|
},
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self compareTransform:CGAffineTransformInvert(testcases[key].testdata)
|
|
with:testcases[key].expdata
|
|
message:key];
|
|
}
|
|
|
|
- (void)testRectApplyAffineTransform
|
|
{
|
|
var rect = CGRectMake(3, 4, 5, 6),
|
|
testcases = {
|
|
"identity does nothing" : {
|
|
testdata: CGRectApplyAffineTransform(rect, CGAffineTransformMakeIdentity() ),
|
|
expdata: rect
|
|
},
|
|
|
|
"rotation 90 degrees" : {
|
|
testdata: CGRectApplyAffineTransform(rect, CGAffineTransformMakeRotation(PI / 2)),
|
|
expdata: CGRectMake(-10, 3.0000000000000004, 6, 5)
|
|
},
|
|
|
|
"translation" : {
|
|
testdata: CGRectApplyAffineTransform(rect, CGAffineTransformMakeTranslation(3, 4)),
|
|
expdata: CGRectMake(6, 8, 5, 6)
|
|
},
|
|
|
|
"scale" : {
|
|
testdata: CGRectApplyAffineTransform(rect, CGAffineTransformMakeScale(1, 4)),
|
|
expdata: CGRectMake(3, 16, 5, 24)
|
|
},
|
|
|
|
"rotate, translate and scale" : {
|
|
testdata: CGRectApplyAffineTransform(rect, CGAffineTransformRotate(CGAffineTransformTranslate(CGAffineTransformMakeScale(3, 4),5,6), PI)),
|
|
expdata: CGRectMake(-9.000000000000004, -16,
|
|
15.000000000000002, 24.000000000000004)
|
|
},
|
|
};
|
|
|
|
for (var key in testcases)
|
|
[self compareRect:testcases[key].testdata with:testcases[key].expdata message:key];
|
|
}
|
|
|
|
@end
|