stuff

01-StackMachine/testcases/tc1.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+#include "stackm.h"
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc10.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doPush(&mystack, 1);
+	smPrint(&mystack);
+	doPush(&mystack, 2);
+	smPrint(&mystack);
+	doPush(&mystack, 3);
+	smPrint(&mystack);
+	doPop(&mystack);
+	smPrint(&mystack);
+	doPop(&mystack);
+	smPrint(&mystack);
+	doPop(&mystack);
+	smPrint(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc11.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doAdd(stackm* s) 
+{
+	printf("Add Ret: %d\n", smAdd(s));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doPush(&mystack, 1);
+	doPush(&mystack, 2);
+	doAdd(&mystack);
+	doPop(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc12.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doAdd(stackm* s) 
+{
+	printf("Add Ret: %d\n", smAdd(s));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+void doTop(stackm* s, int* v)
+{
+	printf("Top Ret: %d\n", smTop(s, v));
+}
+
+int main() {
+	int val = 0;
+	stackm mystack;
+	smInit(&mystack);
+	for(int i = 0 ; i < 10; i++) {
+		doPush(&mystack, i);
+	}
+	for(int i = 0; i < 9; i++) {
+		doAdd(&mystack);
+	}
+	doTop(&mystack, &val);
+	printf("Final Val: %d\n", val);
+	doPop(&mystack);
+	
+	return 0;
+}

01-StackMachine/testcases/tc13.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doSub(stackm* s) 
+{
+	printf("Sub Ret: %d\n", smSub(s));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doPush(&mystack, 1);
+	doPush(&mystack, 2);
+	doSub(&mystack);
+	doPop(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc14.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doSub(stackm* s) 
+{
+	printf("Sub Ret: %d\n", smSub(s));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+void doTop(stackm* s, int* v)
+{
+	printf("Top Ret: %d\n", smTop(s, v));
+}
+
+int main() {
+	int val = 0;
+	stackm mystack;
+	smInit(&mystack);
+	for(int i = 0 ; i < 10; i++) {
+		doPush(&mystack, i);
+	}
+	for(int i = 0; i < 9; i++) {
+		doSub(&mystack);
+	}
+	doTop(&mystack, &val);
+	printf("Final Val: %d\n", val);
+	doPop(&mystack);
+	
+	return 0;
+}

01-StackMachine/testcases/tc15.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doMult(stackm* s) 
+{
+	printf("Mult Ret: %d\n", smMult(s));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doPush(&mystack, 1);
+	doPush(&mystack, 2);
+	doMult(&mystack);
+	doPop(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc16.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doMult(stackm* s) 
+{
+	printf("Mult Ret: %d\n", smMult(s));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+void doTop(stackm* s, int* v)
+{
+	printf("Top Ret: %d\n", smTop(s, v));
+}
+
+int main() {
+	int val = 0;
+	stackm mystack;
+	smInit(&mystack);
+	for(int i = 1 ; i < 11; i++) {
+		doPush(&mystack, i);
+	}
+	for(int i = 0; i < 9; i++) {
+		doMult(&mystack);
+	}
+	doTop(&mystack, &val);
+	printf("Final Val: %d\n", val);
+	doPop(&mystack);
+	
+	return 0;
+}

01-StackMachine/testcases/tc17.c

@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doAdd(stackm* s) 
+{
+	printf("Add Ret: %d\n", smAdd(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doAdd(&mystack);
+	doPush(&mystack, 10);
+	doAdd(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc18.c

@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doSub(stackm* s) 
+{
+	printf("Sub Ret: %d\n", smSub(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doSub(&mystack);
+	doPush(&mystack, 10);
+	doSub(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc19.c

@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doMult(stackm* s) 
+{
+	printf("Mult Ret: %d\n", smMult(s));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doMult(&mystack);
+	doPush(&mystack, 10);
+	doMult(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc2.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doPush(&mystack, 1);
+	doPop(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc20.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+void doRotate(stackm *s, int d) 
+{
+	printf("Rotate Ret: %d\n", smRotate(s, d));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doPush(&mystack, 1);
+	doPush(&mystack, 2);
+	smPrint(&mystack);
+	doRotate(&mystack, 2);
+	smPrint(&mystack);
+	doPop(&mystack);
+	doPop(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc21.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+void doRotate(stackm *s, int d) 
+{
+	printf("Rotate Ret: %d\n", smRotate(s, d));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	for(int i = 0 ; i < 10; i++) {
+		doPush(&mystack, i);
+	}
+	smPrint(&mystack);
+	for(int i = 0; i < 10; i++) {
+		doRotate(&mystack, i+1);
+		smPrint(&mystack);
+	}
+	for(int i = 0; i < 10; i++) {
+		doPop(&mystack);
+	}
+	return 0;
+}

01-StackMachine/testcases/tc22.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+void doRotate(stackm *s, int d) 
+{
+	printf("Rotate Ret: %d\n", smRotate(s, d));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	for(int i = 0 ; i < 10; i++) {
+		doPush(&mystack, i);
+	}
+	smPrint(&mystack);
+	doRotate(&mystack, 100);
+	for(int i = 0; i < 10; i++) {
+		doPop(&mystack);
+	}
+	return 0;
+}

01-StackMachine/testcases/tc23.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+void doRotate(stackm *s, int d) 
+{
+	printf("Rotate Ret: %d\n", smRotate(s, d));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	for(int i = 0 ; i < 10; i++) {
+		doPush(&mystack, i);
+	}
+	smPrint(&mystack);
+	doRotate(&mystack, 0);
+	for(int i = 0; i < 10; i++) {
+		doPop(&mystack);
+	}
+	return 0;
+}

01-StackMachine/testcases/tc24.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doMult(stackm* s) 
+{
+	printf("Mult Ret: %d\n", smMult(s));
+}
+
+void doRotate(stackm *s, int d) 
+{
+	printf("Rotate Ret: %d\n", smRotate(s, d));
+}
+
+void doTop(stackm* s, int* v)
+{
+	printf("Top Ret: %d\n", smTop(s, v));
+}
+
+int main() {
+	int val = 0;
+	stackm mystack;
+	smInit(&mystack);
+	for(int i = 1 ; i <= 10; i++) {
+		doPush(&mystack, i);
+		doPush(&mystack, i);
+		doMult(&mystack);
+	}
+	smPrint(&mystack);
+	doTop(&mystack, &val);
+	while(val > 25) {
+		doRotate(&mystack, 10);
+		doTop(&mystack, &val);
+	}
+	smPrint(&mystack);
+	smClear(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc25.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include "stackm.h"
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	for(int i = 0 ; i < 1000; i++) {
+		smPush(&mystack, i);
+	}
+	smPrint(&mystack);
+	for(int i = 0 ; i < 1000; i++) {
+		smPop(&mystack);
+	}
+	smPrint(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc3.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doPush(&mystack, 1);
+	doPush(&mystack, 2);
+	doPush(&mystack, 3);
+	doPop(&mystack);
+	doPop(&mystack);
+	doPop(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc4.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doPop(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc5.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include "stackm.h"
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	printf("SIZE: %d\n", smSize(&mystack));
+	return 0;
+}

01-StackMachine/testcases/tc6.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doPush(&mystack, 1);
+	doPush(&mystack, 2);
+	doPush(&mystack, 3);
+	printf("SIZE: %d\n", smSize(&mystack));
+	doPop(&mystack);
+	doPop(&mystack);
+	doPop(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc7.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+void doPop(stackm* s) 
+{
+	printf("Pop Ret: %d\n", smPop(s));
+}
+
+void doTop(stackm* s, int* v)
+{
+	printf("Top Ret: %d\n", smTop(s, v));
+}
+
+int main() {
+	int val = 0;
+	stackm mystack;
+	smInit(&mystack);
+	doPush(&mystack, 1);
+	doTop(&mystack, &val);
+	printf("TOP: %d\n", val);
+	doPush(&mystack, 2);
+	doTop(&mystack, &val);
+	printf("TOP: %d\n", val);
+	doPush(&mystack, 3);
+	doTop(&mystack, &val);
+	printf("TOP: %d\n", val);
+	doPop(&mystack);
+	doPop(&mystack);
+	doPop(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc8.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include "stackm.h"
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	smClear(&mystack);
+	return 0;
+}

01-StackMachine/testcases/tc9.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include "stackm.h"
+
+void doPush(stackm* s, int v)
+{
+	printf("Push Ret: %d\n", smPush(s, v));
+}
+
+int main() {
+	stackm mystack;
+	smInit(&mystack);
+	doPush(&mystack, 1);
+	doPush(&mystack, 2);
+	doPush(&mystack, 3);
+	printf("SIZE: %d\n", smSize(&mystack));
+	smClear(&mystack);
+	printf("SIZE: %d\n", smSize(&mystack));
+	return 0;
+}