test/testplatform.c
author Philipp Wiesemann <philipp.wiesemann@arcor.de>
Wed, 18 Feb 2015 21:31:21 +0100
changeset 9356 e87d6e1e812a
parent 9260 039714172dc3
child 9383 62164ad0b7d5
permissions -rw-r--r--
Removed redundant include statements from test programs.

The needed header files are already included with SDL.h. Still including them in
the test programs is confusing because it somehow suggests they would be needed.
     1 /*
     2   Copyright (C) 1997-2014 Sam Lantinga <slouken@libsdl.org>
     3 
     4   This software is provided 'as-is', without any express or implied
     5   warranty.  In no event will the authors be held liable for any damages
     6   arising from the use of this software.
     7 
     8   Permission is granted to anyone to use this software for any purpose,
     9   including commercial applications, and to alter it and redistribute it
    10   freely.
    11 */
    12 
    13 #include <stdio.h>
    14 
    15 #include "SDL.h"
    16 
    17 /*
    18  * Watcom C flags these as Warning 201: "Unreachable code" if you just
    19  *  compare them directly, so we push it through a function to keep the
    20  *  compiler quiet.  --ryan.
    21  */
    22 static int
    23 badsize(size_t sizeoftype, size_t hardcodetype)
    24 {
    25     return sizeoftype != hardcodetype;
    26 }
    27 
    28 int
    29 TestTypes(SDL_bool verbose)
    30 {
    31     int error = 0;
    32 
    33     if (badsize(sizeof(Uint8), 1)) {
    34         if (verbose)
    35             SDL_Log("sizeof(Uint8) != 1, instead = %u\n",
    36                    (unsigned int)sizeof(Uint8));
    37         ++error;
    38     }
    39     if (badsize(sizeof(Uint16), 2)) {
    40         if (verbose)
    41             SDL_Log("sizeof(Uint16) != 2, instead = %u\n",
    42                    (unsigned int)sizeof(Uint16));
    43         ++error;
    44     }
    45     if (badsize(sizeof(Uint32), 4)) {
    46         if (verbose)
    47             SDL_Log("sizeof(Uint32) != 4, instead = %u\n",
    48                    (unsigned int)sizeof(Uint32));
    49         ++error;
    50     }
    51     if (badsize(sizeof(Uint64), 8)) {
    52         if (verbose)
    53             SDL_Log("sizeof(Uint64) != 8, instead = %u\n",
    54                    (unsigned int)sizeof(Uint64));
    55         ++error;
    56     }
    57     if (verbose && !error)
    58         SDL_Log("All data types are the expected size.\n");
    59 
    60     return (error ? 1 : 0);
    61 }
    62 
    63 int
    64 TestEndian(SDL_bool verbose)
    65 {
    66     int error = 0;
    67     Uint16 value = 0x1234;
    68     int real_byteorder;
    69     Uint16 value16 = 0xCDAB;
    70     Uint16 swapped16 = 0xABCD;
    71     Uint32 value32 = 0xEFBEADDE;
    72     Uint32 swapped32 = 0xDEADBEEF;
    73     Uint64 value64, swapped64;
    74 
    75     value64 = 0xEFBEADDE;
    76     value64 <<= 32;
    77     value64 |= 0xCDAB3412;
    78     swapped64 = 0x1234ABCD;
    79     swapped64 <<= 32;
    80     swapped64 |= 0xDEADBEEF;
    81 
    82     if (verbose) {
    83         SDL_Log("Detected a %s endian machine.\n",
    84                (SDL_BYTEORDER == SDL_LIL_ENDIAN) ? "little" : "big");
    85     }
    86     if ((*((char *) &value) >> 4) == 0x1) {
    87         real_byteorder = SDL_BIG_ENDIAN;
    88     } else {
    89         real_byteorder = SDL_LIL_ENDIAN;
    90     }
    91     if (real_byteorder != SDL_BYTEORDER) {
    92         if (verbose) {
    93             SDL_Log("Actually a %s endian machine!\n",
    94                    (real_byteorder == SDL_LIL_ENDIAN) ? "little" : "big");
    95         }
    96         ++error;
    97     }
    98     if (verbose) {
    99         SDL_Log("Value 16 = 0x%X, swapped = 0x%X\n", value16,
   100                SDL_Swap16(value16));
   101     }
   102     if (SDL_Swap16(value16) != swapped16) {
   103         if (verbose) {
   104             SDL_Log("16 bit value swapped incorrectly!\n");
   105         }
   106         ++error;
   107     }
   108     if (verbose) {
   109         SDL_Log("Value 32 = 0x%X, swapped = 0x%X\n", value32,
   110                SDL_Swap32(value32));
   111     }
   112     if (SDL_Swap32(value32) != swapped32) {
   113         if (verbose) {
   114             SDL_Log("32 bit value swapped incorrectly!\n");
   115         }
   116         ++error;
   117     }
   118     if (verbose) {
   119         SDL_Log("Value 64 = 0x%"SDL_PRIX64", swapped = 0x%"SDL_PRIX64"\n", value64,
   120                SDL_Swap64(value64));
   121     }
   122     if (SDL_Swap64(value64) != swapped64) {
   123         if (verbose) {
   124             SDL_Log("64 bit value swapped incorrectly!\n");
   125         }
   126         ++error;
   127     }
   128     return (error ? 1 : 0);
   129 }
   130 
   131 
   132 int
   133 TestCPUInfo(SDL_bool verbose)
   134 {
   135     if (verbose) {
   136         SDL_Log("CPU count: %d\n", SDL_GetCPUCount());
   137         SDL_Log("CPU cache line size: %d\n", SDL_GetCPUCacheLineSize());
   138         SDL_Log("RDTSC %s\n", SDL_HasRDTSC()? "detected" : "not detected");
   139         SDL_Log("AltiVec %s\n", SDL_HasAltiVec()? "detected" : "not detected");
   140         SDL_Log("MMX %s\n", SDL_HasMMX()? "detected" : "not detected");
   141         SDL_Log("3DNow! %s\n", SDL_Has3DNow()? "detected" : "not detected");
   142         SDL_Log("SSE %s\n", SDL_HasSSE()? "detected" : "not detected");
   143         SDL_Log("SSE2 %s\n", SDL_HasSSE2()? "detected" : "not detected");
   144         SDL_Log("SSE3 %s\n", SDL_HasSSE3()? "detected" : "not detected");
   145         SDL_Log("SSE4.1 %s\n", SDL_HasSSE41()? "detected" : "not detected");
   146         SDL_Log("SSE4.2 %s\n", SDL_HasSSE42()? "detected" : "not detected");
   147         SDL_Log("AVX %s\n", SDL_HasAVX()? "detected" : "not detected");
   148         SDL_Log("System RAM %d MB\n", SDL_GetSystemRAM());
   149     }
   150     return (0);
   151 }
   152 
   153 int
   154 TestAssertions(SDL_bool verbose)
   155 {
   156     SDL_assert(1);
   157     SDL_assert_release(1);
   158     SDL_assert_paranoid(1);
   159     SDL_assert(0 || 1);
   160     SDL_assert_release(0 || 1);
   161     SDL_assert_paranoid(0 || 1);
   162 
   163 #if 0   /* enable this to test assertion failures. */
   164     SDL_assert_release(1 == 2);
   165     SDL_assert_release(5 < 4);
   166     SDL_assert_release(0 && "This is a test");
   167 #endif
   168 
   169     {
   170         const SDL_assert_data *item = SDL_GetAssertionReport();
   171         while (item) {
   172             SDL_Log("'%s', %s (%s:%d), triggered %u times, always ignore: %s.\n",
   173                 item->condition, item->function, item->filename,
   174                 item->linenum, item->trigger_count,
   175                 item->always_ignore ? "yes" : "no");
   176             item = item->next;
   177         }
   178     }
   179     return (0);
   180 }
   181 
   182 int
   183 main(int argc, char *argv[])
   184 {
   185     SDL_bool verbose = SDL_TRUE;
   186     int status = 0;
   187 
   188     /* Enable standard application logging */
   189     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
   190 
   191     if (argv[1] && (SDL_strcmp(argv[1], "-q") == 0)) {
   192         verbose = SDL_FALSE;
   193     }
   194     if (verbose) {
   195         SDL_Log("This system is running %s\n", SDL_GetPlatform());
   196     }
   197 
   198     status += TestTypes(verbose);
   199     status += TestEndian(verbose);
   200     status += TestCPUInfo(verbose);
   201     status += TestAssertions(verbose);
   202 
   203     return status;
   204 }