summary refs log tree commit diff stats
path: root/emacs-lisp
diff options
context:
space:
mode:
authorAndinus <andinus@nand.sh>2021-09-05 22:23:27 +0530
committerAndinus <andinus@nand.sh>2021-09-05 22:23:27 +0530
commit670546b8a284bee51f63f00dabcf89b9ea463e68 (patch)
tree3d50372887f2931eb714405a12aeafad28049aa1 /emacs-lisp
parent27d42698a76605b0653474e8d0d0976b74cd2b88 (diff)
downloadexercism-670546b8a284bee51f63f00dabcf89b9ea463e68.tar.gz
JS: Luhn: Add solution
Diffstat (limited to 'emacs-lisp')
0 files changed, 0 insertions, 0 deletions
b0d2013a4479fb3d005a'>^
5f05e954 ^

51530916 ^
6a9d8191 ^
51530916 ^

1ba81b0f ^
b39ceb27 ^
2ed1aa9c ^
51530916 ^

1ba81b0f ^
51530916 ^
60c566ea ^
54e4548d ^
51530916 ^
2ed1aa9c ^
51530916 ^


60c566ea ^
54e4548d ^
51530916 ^

2ed1aa9c ^
51530916 ^

de49fb42 ^


b39ceb27 ^
df0b469f ^
b39ceb27 ^






51530916 ^
b39ceb27 ^
6c96a437 ^
9e608a77 ^
6c96a437 ^
6c1376f8 ^
9e608a77 ^

b39ceb27 ^
5a9e3a11 ^
683d53ca ^
b39ceb27 ^


683d53ca ^

b39ceb27 ^
df0b469f ^
ccd792da ^
51530916 ^
ac0e9db5 ^
7d13531e ^



eb3a527a ^


b5ab709c ^
fb4836dc ^
b5ab709c ^
eef0251c ^
51530916 ^

0f125d5f ^
ad6eb923 ^


86acd630 ^

b24eb476 ^
eb3a527a ^
65ccad4c ^
b24eb476 ^
40be2522 ^
eb3a527a ^



37537bf3 ^









51530916 ^
f2043a73 ^
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
                                                                              
                                              
                 
   




                                                                              


                              

                                                                                  
                         
                                                             

  
                       
                       
                                                                             

                      
                        
                  
                         
                                                                                                    
                     
                                                                 


                        
                               
                                                                                                                    

                                                                   
                                                                 

   


                     
                                   
                                            






                                                                                  
 
                                
                      
                                   
                                                               
                          

                
               
              
                         


                                         

             
           
 
 
       
                         



                                            


                   
                      
             
                          
                      

 
                                  


                                                                                   

 
                          
                   
                                                                    
                                                       
                                                                       



                       









                                              
                        
                   
//: A simple test harness. To create new tests, define functions starting with
//: 'test_'. To run all tests so defined, run:
//:   $ ./mu test
//:
//: Every layer should include tests, and can reach into previous layers.
//: However, it seems like a good idea never to reach into tests from previous
//: layers. Every test should be a contract that always passes as originally
//: written, regardless of any later layers. Avoid writing 'temporary' tests
//: that are only meant to work until some layer.

:(before "End Types")
typedef void (*test_fn)(void);
:(before "Globals")
// move a global ahead into types that we can't generate an extern declaration for
const test_fn Tests[] = {
  #include "test_list"  // auto-generated; see 'build' script
};

:(before "End Globals")
bool Run_tests = false;
bool Passed = true;  // set this to false inside any test to indicate failure
long Num_failures = 0;

:(before "End Includes")
#define CHECK(X) \
  if (Passed && !(X)) { \
    cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): " << #X << '\n'; \
    Passed = false; \
    return;  /* Currently we stop at the very first failure. */ \
  }

#define CHECK_EQ(X, Y) \
  if (Passed && (X) != (Y)) { \
    cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): " << #X << " == " << #Y << '\n'; \
    cerr << "  got " << (X) << '\n';  /* BEWARE: multiple eval */ \
    Passed = false; \
    return;  /* Currently we stop at the very first failure. */ \
  }

:(before "End Setup")
Passed = true;

:(before "End Commandline Parsing")
if (argc > 1 && is_equal(argv[1], "test")) {
  Run_tests = true;  --argc;  ++argv;  // shift 'test' out of commandline args
}

:(before "End Main")
if (Run_tests) {
  // Test Runs
  // we run some tests and then exit; assume no state need be maintained afterward

  // End Test Run Initialization
  time_t t;  time(&t);
  cerr << "C tests: " << ctime(&t);
  for (size_t i=0;  i < sizeof(Tests)/sizeof(Tests[0]);  ++i) {
//?     cerr << i << '\n';
    run_test(i);
  }
  cerr << '\n';
  // End Tests
  if (Num_failures > 0) {
    cerr << Num_failures << " failure"
         << (Num_failures > 1 ? "s" : "")
         << '\n';
    return 1;
  }
  return 0;
}

:(code)
void run_test(size_t i) {
  if (i >= sizeof(Tests)/sizeof(Tests[0])) {
    cerr << "no test " << i << '\n';
    return;
  }
  setup();
  // End Test Setup
  (*Tests[i])();
  // End Test Teardown
  teardown();
  if (Passed) cerr << '.';
  else ++Num_failures;
}

bool is_integer(const string& s) {
  return s.find_first_not_of("0123456789-") == string::npos  // no other characters
      && s.find_first_of("0123456789") != string::npos  // at least one digit
      && s.find('-', 1) == string::npos;  // '-' only at first position
}

int to_integer(string n) {
  char* end = NULL;
  // safe because string.c_str() is guaranteed to be null-terminated
  int result = strtoll(n.c_str(), &end, /*any base*/0);
  if (*end != '\0') cerr << "tried to convert " << n << " to number\n";
  assert(*end == '\0');
  return result;
}

void test_is_integer() {
  CHECK(is_integer("1234"));
  CHECK(is_integer("-1"));
  CHECK(!is_integer("234.0"));
  CHECK(is_integer("-567"));
  CHECK(!is_integer("89-0"));
  CHECK(!is_integer("-"));
  CHECK(!is_integer("1e3"));  // not supported
}

:(before "End Includes")
#include <stdlib.h>