/* * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, * 2018, 2019 * Jonathan Schleifer * * All rights reserved. * * This file is part of ObjFW. It may be distributed under the terms of the * Q Public License 1.0, which can be found in the file LICENSE.QPL included in * the packaging of this file. * * Alternatively, it may be distributed under the terms of the GNU General * Public License, either version 2 or 3, which can be found in the file * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #include "config.h" #include #include #if defined(HAVE_COMPLEX_H) && !defined(__STDC_NO_COMPLEX__) # include #endif #import "TestsAppDelegate.h" static OFString *module = @"OFInvocation"; struct test_struct { unsigned char c; unsigned int i; }; @implementation TestsAppDelegate (OFInvocationTests) - (struct test_struct)invocationTestMethod1: (unsigned char)c : (unsigned int)i : (struct test_struct *)ptr : (struct test_struct)st { return st; } #ifdef OF_INVOCATION_CAN_INVOKE - (void)invocationTestMethod2: (id)obj { assert(obj == self); } - (int)invocationTestMethod3: (int)i1 : (int)i2 : (int)i3 : (int)i4 : (int)i5 : (int)i6 : (int)i7 : (int)i8 : (int)i9 : (int)i10 : (int)i11 : (int)i12 : (int)i13 : (int)i14 : (int)i15 : (int)i16 { return (i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9 + i10 + i11 + i12 + i13 + i14 + i15 + i16) / 16; } - (double)invocationTestMethod4: (double)d1 : (double)d2 : (double)d3 : (double)d4 : (double)d5 : (double)d6 : (double)d7 : (double)d8 : (double)d9 : (double)d10 : (double)d11 : (double)d12 : (double)d13 : (double)d14 : (double)d15 : (double)d16 { return (d1 + d2 + d3 + d4 + d5 + d6 + d7 + d8 + d9 + d10 + d11 + d12 + d13 + d14 + d15 + d16) / 16; } - (float)invocationTestMethod5: (double)d1 : (float)f2 : (float)f3 : (float)f4 : (float)f5 : (float)f6 : (float)f7 : (float)f8 : (float)f9 : (double)d10 : (float)f11 : (float)f12 : (float)f13 : (float)f14 : (float)f15 : (float)f16 { return (float)((d1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + d10 + f11 + f12 + f13 + f14 + f15 + f16) / 16); } - (long double)invocationTestMethod6: (long double)d1 : (long double)d2 : (long double)d3 : (long double)d4 : (long double)d5 : (long double)d6 : (long double)d7 : (long double)d8 : (long double)d9 : (long double)d10 : (long double)d11 : (long double)d12 : (long double)d13 : (long double)d14 : (long double)d15 : (long double)d16 { return (d1 + d2 + d3 + d4 + d5 + d6 + d7 + d8 + d9 + d10 + d11 + d12 + d13 + d14 + d15 + d16) / 16; } # if defined(HAVE_COMPLEX_H) && !defined(__STDC_NO_COMPLEX__) - (complex double)invocationTestMethod7: (complex float)c1 : (complex double)c2 : (complex float)c3 : (complex double)c4 : (complex float)c5 : (complex double)c6 : (complex float)c7 : (complex double)c8 : (complex float)c9 : (complex double)c10 : (complex float)c11 : (complex double)c12 : (complex float)c13 : (complex double)c14 : (complex float)c15 : (complex double)c16 { OF_ENSURE(creal(c1) == 1.0 && cimag(c1) == 0.5); OF_ENSURE(creal(c2) == 2.0 && cimag(c2) == 1.0); OF_ENSURE(creal(c3) == 3.0 && cimag(c3) == 1.5); OF_ENSURE(creal(c4) == 4.0 && cimag(c4) == 2.0); OF_ENSURE(creal(c5) == 5.0 && cimag(c5) == 2.5); OF_ENSURE(creal(c6) == 6.0 && cimag(c6) == 3.0); OF_ENSURE(creal(c7) == 7.0 && cimag(c7) == 3.5); OF_ENSURE(creal(c8) == 8.0 && cimag(c8) == 4.0); OF_ENSURE(creal(c9) == 9.0 && cimag(c9) == 4.5); OF_ENSURE(creal(c10) == 10.0 && cimag(c10) == 5.0); OF_ENSURE(creal(c11) == 11.0 && cimag(c11) == 5.5); OF_ENSURE(creal(c12) == 12.0 && cimag(c12) == 6.0); OF_ENSURE(creal(c13) == 13.0 && cimag(c13) == 6.5); OF_ENSURE(creal(c14) == 14.0 && cimag(c14) == 7.0); OF_ENSURE(creal(c15) == 15.0 && cimag(c15) == 7.5); OF_ENSURE(creal(c16) == 16.0 && cimag(c16) == 8.0); return (c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11 + c12 + c13 + c14 + c15 + c16) / 16; } - (complex long double)invocationTestMethod8: (complex double)c1 : (complex float)c2 : (complex long double)c3 : (complex double)c4 : (complex float)c5 : (complex long double)c6 : (complex double)c7 : (complex float)c8 : (complex long double)c9 : (complex double)c10 : (complex float)c11 : (complex long double)c12 : (complex double)c13 : (complex float)c14 : (complex long double)c15 : (complex double)c16 { OF_ENSURE(creal(c1) == 1.0 && cimag(c1) == 0.5); OF_ENSURE(creal(c2) == 2.0 && cimag(c2) == 1.0); OF_ENSURE(creal(c3) == 3.0 && cimag(c3) == 1.5); OF_ENSURE(creal(c4) == 4.0 && cimag(c4) == 2.0); OF_ENSURE(creal(c5) == 5.0 && cimag(c5) == 2.5); OF_ENSURE(creal(c6) == 6.0 && cimag(c6) == 3.0); OF_ENSURE(creal(c7) == 7.0 && cimag(c7) == 3.5); OF_ENSURE(creal(c8) == 8.0 && cimag(c8) == 4.0); OF_ENSURE(creal(c9) == 9.0 && cimag(c9) == 4.5); OF_ENSURE(creal(c10) == 10.0 && cimag(c10) == 5.0); OF_ENSURE(creal(c11) == 11.0 && cimag(c11) == 5.5); OF_ENSURE(creal(c12) == 12.0 && cimag(c12) == 6.0); OF_ENSURE(creal(c13) == 13.0 && cimag(c13) == 6.5); OF_ENSURE(creal(c14) == 14.0 && cimag(c14) == 7.0); OF_ENSURE(creal(c15) == 15.0 && cimag(c15) == 7.5); OF_ENSURE(creal(c16) == 16.0 && cimag(c16) == 8.0); return (c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11 + c12 + c13 + c14 + c15 + c16) / 16; } # endif # ifdef __SIZEOF_INT128__ __extension__ - (__int128)invocationTestMethod9: (int)i1 : (__int128)i2 : (__int128)i3 : (__int128)i4 : (int)i5 : (__int128)i6 : (__int128)i7 : (__int128)i8 : (__int128)i9 : (__int128)i10 : (__int128)i11 : (__int128)i12 : (__int128)i13 : (__int128)i14 : (__int128)i15 : (__int128)i16 { __int128 mask = (__int128)0xFFFFFFFFFFFFFFFF << 64; OF_ENSURE(i1 == 1); OF_ENSURE(i2 == mask + 2); OF_ENSURE(i3 == mask + 3); OF_ENSURE(i4 == mask + 4); OF_ENSURE(i5 == 5); OF_ENSURE(i6 == mask + 6); OF_ENSURE(i7 == mask + 7); OF_ENSURE(i8 == mask + 8); OF_ENSURE(i9 == mask + 9); OF_ENSURE(i10 == mask + 10); OF_ENSURE(i11 == mask + 11); OF_ENSURE(i12 == mask + 12); OF_ENSURE(i13 == mask + 13); OF_ENSURE(i14 == mask + 14); OF_ENSURE(i15 == mask + 15); OF_ENSURE(i16 == mask + 16); return ((i1 + (int)i2 + (int)i3 + (int)i4 + i5 + (int)i6 + (int)i7 + (int)i8 + (int)i9 + (int)i10 + (int)i11 + (int)i12 + (int)i13 + (int)i14 + (int)i15 + (int)i16) / 16) + mask; } # endif #endif - (void)invocationTests { void *pool = objc_autoreleasePoolPush(); SEL selector = @selector(invocationTestMethod1::::); OFMethodSignature *sig = [self methodSignatureForSelector: selector]; OFInvocation *invocation; struct test_struct st, st2, *stp = &st, *stp2; unsigned const char c = 0xAA; unsigned char c2; const unsigned int i = 0x55555555; unsigned int i2; memset(&st, '\xFF', sizeof(st)); st.c = 0x55; st.i = 0xAAAAAAAA; TEST(@"+[invocationWithMethodSignature:]", (invocation = [OFInvocation invocationWithMethodSignature: sig])) #ifdef __clang_analyzer__ assert(invocation != nil); #endif TEST(@"-[setReturnValue]", R([invocation setReturnValue: &st])) TEST(@"-[getReturnValue]", R([invocation getReturnValue: &st2]) && memcmp(&st, &st2, sizeof(st)) == 0) memset(&st2, '\0', sizeof(st2)); TEST(@"-[setArgument:atIndex:] #1", R([invocation setArgument: &c atIndex: 2])) TEST(@"-[setArgument:atIndex:] #2", R([invocation setArgument: &i atIndex: 3])) TEST(@"-[setArgument:atIndex:] #3", R([invocation setArgument: &stp atIndex: 4])) TEST(@"-[setArgument:atIndex:] #4", R([invocation setArgument: &st atIndex: 5])) TEST(@"-[getArgument:atIndex:] #1", R([invocation getArgument: &c2 atIndex: 2]) && c == c2) TEST(@"-[getArgument:atIndex:] #2", R([invocation getArgument: &i2 atIndex: 3]) && i == i2) TEST(@"-[getArgument:atIndex:] #3", R([invocation getArgument: &stp2 atIndex: 4]) && stp == stp2) TEST(@"-[getArgument:atIndex:] #4", R([invocation getArgument: &st2 atIndex: 5]) && memcmp(&st, &st2, sizeof(st)) == 0) objc_autoreleasePoolPop(pool); } @end