mirror of
https://github.com/cappuccino/cappuccino.git
synced 2026-08-25 21:17:03 +00:00
512 lines
17 KiB
Plaintext
512 lines
17 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(Math.PI),
|
|
CGAffineTransformMakeRotation(-Math.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(-Math.PI),
|
|
CGAffineTransformMakeRotation(Math.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(Math.PI),
|
|
},
|
|
|
|
// TODO a two-pi rotation is actually identity
|
|
"2PI rotation is NOT identity?" : {
|
|
testdata: CGAffineTransformMakeRotation(Math.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(Math.PI),
|
|
rhs: CGAffineTransformMakeRotation(Math.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(Math.PI),
|
|
expdata: "{-1, 1.2246467991473532e-16, -1.2246467991473532e-16, -1, 0, 0}"
|
|
},
|
|
|
|
"rotation - 2pi" : {
|
|
testdata: CGAffineTransformMakeRotation(2 * Math.PI),
|
|
expdata: "{1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 0, 0}"
|
|
},
|
|
|
|
"rotation - 3pi" : {
|
|
testdata: CGAffineTransformMakeRotation(3 * Math.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),Math.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 = Math.PI + 0.5 * Math.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),Math.PI),-Math.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),Math.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(-Math.PI),
|
|
expdata: CGAffineTransformMakeRotation(Math.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 );
|
|
|
|
var testcases = {
|
|
"identity does nothing" : {
|
|
testdata: CGRectApplyAffineTransform(rect, CGAffineTransformMakeIdentity() ),
|
|
expdata: rect
|
|
},
|
|
|
|
"rotation 90 degrees" : {
|
|
testdata: CGRectApplyAffineTransform(rect, CGAffineTransformMakeRotation(Math.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),Math.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
|