bobbylucero/Bob
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up test files

Browse Source
This commit is contained in:
Bobby Lucero 2025-08-07 02:07:54 -04:00
parent 32910b1e57
commit 2104fbe1f5
48 changed files with 0 additions and 4832 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
app.config
View File

@ -1,8 +0,0 @@
# Application Configuration
server_port=8080
database_url=postgresql://localhost:5432/mydb
debug_mode=true
max_connections=100
log_level=INFO
cache_size=1024
timeout=30

3
app.log
View File

@ -1,3 +0,0 @@
2024-01-15 10:30:15 INFO Started
2024-01-15 10:30:16 INFO Loaded config
2024-01-15 10:30:17 INFO Ready

1
backup.txt
View File

@ -1 +0,0 @@
Important data

178
char_printer.bob
View File

@ -1,178 +0,0 @@
print("=== CHARACTER PRINTER PROGRAM ===");
print("Demonstrating string indexing by printing each character...");
// ========================================
// MAIN PROGRAM
// ========================================
var message = "Hello, Bob Language!";
print("\n📝 Original message: " + message);
print("📏 Message length: " + toString(len(message)));
print("\n🔤 CHARACTER BREAKDOWN:");
print("┌─────┬─────┬─────────────┬─────────────┐");
print("│ IDX │ CHR │ ASCII CODE │ DESCRIPTION │");
print("├─────┼─────┼─────────────┼─────────────┤");
for (var i = 0; i < len(message); i = i + 1) {
var char = message[i];
var index = toString(i);
var description = "";
// Determine character description
if (char == " ") {
description = "Space";
} else if (char == ",") {
description = "Comma";
} else if (char == "!") {
description = "Exclamation";
} else if (char == "H") {
description = "Capital H";
} else if (char == "e") {
description = "Lowercase e";
} else if (char == "l") {
description = "Lowercase l";
} else if (char == "o") {
description = "Lowercase o";
} else if (char == "B") {
description = "Capital B";
} else if (char == "b") {
description = "Lowercase b";
} else if (char == "L") {
description = "Capital L";
} else if (char == "a") {
description = "Lowercase a";
} else if (char == "n") {
description = "Lowercase n";
} else if (char == "g") {
description = "Lowercase g";
} else if (char == "u") {
description = "Lowercase u";
} else if (char == "r") {
description = "Lowercase r";
} else {
description = "Other";
}
// Format the output line
var line = "│ " + index;
if (len(index) == 1) {
line = line + " ";
} else {
line = line + " ";
}
line = line + "│ " + char + " │ ";
// Add ASCII code (simplified)
var asciiCode = "";
if (char == "H") asciiCode = "72";
else if (char == "e") asciiCode = "101";
else if (char == "l") asciiCode = "108";
else if (char == "o") asciiCode = "111";
else if (char == ",") asciiCode = "44";
else if (char == " ") asciiCode = "32";
else if (char == "B") asciiCode = "66";
else if (char == "b") asciiCode = "98";
else if (char == "L") asciiCode = "76";
else if (char == "a") asciiCode = "97";
else if (char == "n") asciiCode = "110";
else if (char == "g") asciiCode = "103";
else if (char == "u") asciiCode = "117";
else if (char == "r") asciiCode = "114";
else if (char == "!") asciiCode = "33";
else asciiCode = "??";
line = line + asciiCode;
if (len(asciiCode) == 2) {
line = line + " │ ";
} else {
line = line + " │ ";
}
line = line + description;
// Pad description to fit
while (len(line) < 45) {
line = line + " ";
}
line = line + " │";
print(line);
}
print("└─────┴─────┴─────────────┴─────────────┘");
// ========================================
// CHARACTER STATISTICS
// ========================================
print("\n📊 CHARACTER STATISTICS:");
var uppercaseCount = 0;
var lowercaseCount = 0;
var spaceCount = 0;
var punctuationCount = 0;
for (var i = 0; i < len(message); i = i + 1) {
var char = message[i];
if (char == "H" || char == "B" || char == "L") {
uppercaseCount = uppercaseCount + 1;
} else if (char == "e" || char == "l" || char == "o" || char == "b" || char == "a" || char == "n" || char == "g" || char == "u" || char == "r") {
lowercaseCount = lowercaseCount + 1;
} else if (char == " ") {
spaceCount = spaceCount + 1;
} else if (char == "," || char == "!") {
punctuationCount = punctuationCount + 1;
}
}
print(" Uppercase letters: " + toString(uppercaseCount));
print(" Lowercase letters: " + toString(lowercaseCount));
print(" Spaces: " + toString(spaceCount));
print(" Punctuation: " + toString(punctuationCount));
// ========================================
// REVERSE PRINTING
// ========================================
print("\n🔄 REVERSE CHARACTER PRINTING:");
var reverseMessage = "";
for (var i = len(message) - 1; i >= 0; i = i - 1) {
var char = message[i];
reverseMessage = reverseMessage + char;
print(" Index " + toString(i) + ": " + char);
}
print(" Reversed message: " + reverseMessage);
// ========================================
// CHARACTER SEARCH
// ========================================
print("\n🔍 CHARACTER SEARCH:");
var searchChar = "o";
var positions = [];
for (var i = 0; i < len(message); i = i + 1) {
if (message[i] == searchChar) {
push(positions, i);
}
}
print(" Character '" + searchChar + "' found at positions: ");
for (var i = 0; i < len(positions); i = i + 1) {
print(" Index " + toString(positions[i]));
}
// ========================================
// SUMMARY
// ========================================
print("\n🎉 CHARACTER PRINTER COMPLETE!");
print("✅ Successfully printed each character");
print("✅ Analyzed character statistics");
print("✅ Demonstrated reverse printing");
print("✅ Performed character search");
print("✅ Showed string indexing capabilities");
print("\n🏆 STRING INDEXING IS WORKING PERFECTLY!");
print("Bob can now process text character by character!");
print("Ready for advanced text processing tasks!");
print("\n🎊 PROGRAM COMPLETE! 🎊");

6
complex_test.bob
View File

@ -1,6 +0,0 @@
print("=== COMPLEX CODE ===");
var testArray = [];
for (var i = 0; i < 5; i = i + 1) {
push(testArray, i * i);
}
print("Array: " + toString(len(testArray)) + " elements");

49
complexity_test.bob
View File

@ -1,49 +0,0 @@
print("=== COMPLEXITY TEST ===");
// Test 1: Multiple statements in one eval
print("Test 1: Multiple statements");
var code1 = "var a = 1; var b = 2; print(\"a = \" + toString(a) + \", b = \" + toString(b));";
var result1 = eval(code1);
print("Test 1 passed");
// Test 2: Loop in eval
print("Test 2: Loop in eval");
var code2 = "for (var i = 0; i < 3; i = i + 1) { print(\"i = \" + toString(i)); }";
var result2 = eval(code2);
print("Test 2 passed");
// Test 3: Array operations in eval
print("Test 3: Array operations");
var code3 = "var arr = []; push(arr, 1); push(arr, 2); print(\"Array length: \" + toString(len(arr)));";
var result3 = eval(code3);
print("Test 3 passed");
// Test 4: String indexing in eval
print("Test 4: String indexing");
var code4 = "var str = \"Hello\"; print(\"First char: \" + str[0]);";
var result4 = eval(code4);
print("Test 4 passed");
// Test 5: Function definition and call in eval
print("Test 5: Function in eval");
var code5 = "func add(x, y) { return x + y; } var sum = add(5, 3); print(\"Sum: \" + toString(sum));";
var result5 = eval(code5);
print("Test 5 passed");
// Test 6: Write complex code to file and eval
print("Test 6: Complex file I/O");
var complexCode = "print(\"=== COMPLEX CODE ===\");\n";
complexCode = complexCode + "var testArray = [];\n";
complexCode = complexCode + "for (var i = 0; i < 5; i = i + 1) {\n";
complexCode = complexCode + " push(testArray, i * i);\n";
complexCode = complexCode + "}\n";
complexCode = complexCode + "print(\"Array: \" + toString(len(testArray)) + \" elements\");\n";
writeFile("complex_test.bob", complexCode);
var loadedComplex = readFile("complex_test.bob");
print("Generated code:");
print(loadedComplex);
var result6 = eval(loadedComplex);
print("Test 6 passed");
print("All complexity tests passed!");

3
config.txt
View File

@ -1,3 +0,0 @@
server=localhost
port=8080
debug=true

22
debug_generation.bob
View File

@ -1,22 +0,0 @@
print("=== DEBUG GENERATION ===");
print("Let's see exactly what code is being generated...");
// Create a simple test program
var testCode = "print(\"Hello World\");\n";
testCode = testCode + "var x = 5;\n";
testCode = testCode + "print(\"x = \" + toString(x));\n";
// Write it to a file
writeFile("debug_test.bob", testCode);
print("✅ Test code written to file");
// Read it back and show what we actually wrote
var readCode = readFile("debug_test.bob");
print("✅ Code read back from file");
print("Generated code:");
print(readCode);
// Now let's try to eval it
print("\nTrying to eval the generated code...");
var evalResult = eval(readCode);
print("✅ Eval successful!");

3
debug_test.bob
View File

@ -1,3 +0,0 @@
print("Hello World");
var x = 5;
print("x = " + toString(x));

1
file1.txt
View File

@ -1 +0,0 @@
Content 1

1
file2.txt
View File

@ -1 +0,0 @@
Content 2

1
file3.txt
View File

@ -1 +0,0 @@
Content 3

134
final_regression_dynamic.bob
View File

@ -1,134 +0,0 @@
print("=== FINAL REGRESSION BUSTER ===");
print("Testing ALL features together...");
var megaArray = [];
var megaDict = {};
var megaString = "FINAL_TEST_STRING";
var megaNumber = 999999999.999999999;
var megaBoolean = true;
var megaNone = none;
for (var i = 0; i < 50; i = i + 1) {
var nestedArray = [];
var nestedDict = {};
for (var j = 0; j < 5; j = j + 1) {
push(nestedArray, "nested_" + toString(i) + "_" + toString(j));
nestedDict["key_" + toString(i) + "_" + toString(j)] = "value_" + toString(i) + "_" + toString(j);
}
push(megaArray, nestedArray);
megaDict["dict_" + toString(i)] = nestedDict;
}
for (var funcIndex = 0; funcIndex < 10; funcIndex = funcIndex + 1) {
var funcName = "megaFunc_" + toString(funcIndex);
var funcCode = "func " + funcName + "(a, b, c, d, e) { ";
funcCode = funcCode + "var result = a + b * c - d / e; ";
funcCode = funcCode + "if (result > 1000) { ";
funcCode = funcCode + "return result * 2; ";
funcCode = funcCode + "} else { ";
funcCode = funcCode + "return result / 2; ";
funcCode = funcCode + "} ";
funcCode = funcCode + "} ";
eval(funcCode);
var testResult = eval(funcName + "(10, 20, 30, 5, 2)");
print("Generated and tested " + funcName + ": " + toString(testResult));
}
var complexString = "Hello, Bob Language! This is a FINAL test with numbers 12345";
var stringAnalysis = {};
for (var i = 0; i < len(complexString); i = i + 1) {
var char = complexString[i];
var charInfo = {};
charInfo["character"] = char;
charInfo["index"] = i;
charInfo["ascii_approx"] = i * 2 + 32;
if (char == " ") { charInfo["type"] = "space"; }
else if (char == "," || char == "!") { charInfo["type"] = "symbol"; }
else if (char == "0" || char == "1" || char == "2" || char == "3" || char == "4" || char == "5" || char == "6" || char == "7" || char == "8" || char == "9") { charInfo["type"] = "digit"; }
else if (char == "H" || char == "B" || char == "L") { charInfo["type"] = "uppercase"; }
else { charInfo["type"] = "lowercase"; }
stringAnalysis["char_" + toString(i)] = charInfo;
}
func megaRecursiveTorture(n, depth, accumulator) {
if (depth > 20) { return accumulator; }
var currentString = "depth_" + toString(depth) + "_value_" + toString(n);
var reversedString = "";
for (var i = len(currentString) - 1; i >= 0; i = i - 1) {
reversedString = reversedString + currentString[i];
}
var tempArray = [];
for (var i = 0; i < depth; i = i + 1) {
push(tempArray, reversedString + "_" + toString(i));
}
var tempDict = {};
tempDict["depth"] = depth;
tempDict["value"] = n;
tempDict["string"] = currentString;
tempDict["reversed"] = reversedString;
tempDict["array"] = tempArray;
push(accumulator, tempDict);
return megaRecursiveTorture(n * 2 + depth, depth + 1, accumulator);
}
var recursiveResult = megaRecursiveTorture(1, 0, []);
var megaArray2 = [];
var megaArray3 = [];
for (var i = 0; i < 100; i = i + 1) {
var complexValue = {};
complexValue["index"] = i;
complexValue["square"] = i * i;
complexValue["cube"] = i * i * i;
complexValue["string"] = "value_" + toString(i);
complexValue["array"] = [i, i + 1, i + 2, i + 3, i + 4];
complexValue["dict"] = {"nested": i, "deep": i * 2};
push(megaArray2, complexValue);
if (i % 2 == 0) { push(megaArray3, i * 2); } else { push(megaArray3, i * 3); }
}
for (var evalIndex = 0; evalIndex < 10; evalIndex = evalIndex + 1) {
var evalCode = "var evalVar_" + toString(evalIndex) + " = " + toString(evalIndex) + " * " + toString(evalIndex) + " + " + toString(evalIndex) + ";";
evalCode = evalCode + "var evalString_" + toString(evalIndex) + " = \"eval_string_" + toString(evalIndex) + "\";";
evalCode = evalCode + "var evalArray_" + toString(evalIndex) + " = [" + toString(evalIndex) + ", " + toString(evalIndex + 1) + ", " + toString(evalIndex + 2) + "];";
evalCode = evalCode + "var evalResult_" + toString(evalIndex) + " = evalVar_" + toString(evalIndex) + " + len(evalString_" + toString(evalIndex) + ") + len(evalArray_" + toString(evalIndex) + ");";
evalCode = evalCode + "evalResult_" + toString(evalIndex);
var evalResult = eval(evalCode);
print("Eval torture progress: " + toString(evalIndex) + "/10");
}
var loopResults = [];
var loopCounter = 0;
for (var i = 0; i < 10; i = i + 1) {
for (var j = 0; j < 5; j = j + 1) {
for (var k = 0; k < 5; k = k + 1) {
var loopValue = i * j * k;
var loopString = "loop_" + toString(i) + "_" + toString(j) + "_" + toString(k);
var reversedString = "";
for (var l = 0; l < len(loopString); l = l + 1) {
reversedString = reversedString + loopString[len(loopString) - 1 - l];
}
var loopObject = {
"value": loopValue,
"string": loopString,
"reversed": reversedString,
"sum": i + j + k
};
push(loopResults, loopObject);
loopCounter = loopCounter + 1;
}
}
}
print("🎉 FINAL REGRESSION BUSTER COMPLETE!");
print("✅ All phases completed successfully!");
print("✅ Every feature tested against every other feature!");
print("✅ Maximum complexity achieved!");
print("✅ No regressions detected!");
print("📊 FINAL STATISTICS:");
print(" • Variables created: 100+");
print(" • Functions generated: 10+");
print(" • Arrays processed: 500+ elements");
print(" • Dictionaries created: 100+ entries");
print(" • String characters processed: 100+");
print(" • Eval statements executed: 10+");
print(" • Loop iterations: 250+");
print(" • Conditional checks: 100+");
print(" • Arithmetic operations: 1000+");
print(" • Type conversions: 50+");
print("🏆 FINAL REGRESSION TEST PASSED!");
print("Bob is ROCK SOLID under maximum stress!");
print("All features work perfectly together!");
print("Ready for production use!");
print("🚀 BOB IS UNSTOPPABLE! 🚀");
print("🎊 FINAL REGRESSION BUSTER COMPLETE! 🎊");

252
final_regression_test.bob
View File

@ -1,252 +0,0 @@
print("=== FINAL REGRESSION TEST ===");
print("Demonstrating file I/O and eval with complex programs...");
// ========================================
// PHASE 1: WRITE A WORKING COMPLEX PROGRAM
// ========================================
print("\n📝 PHASE 1: Writing working complex program to file...");
var programCode = "print(\"=== FINAL REGRESSION BUSTER ===\");\n";
programCode = programCode + "print(\"Testing ALL features together...\");\n";
// Add massive variable declarations
programCode = programCode + "var megaArray = [];\n";
programCode = programCode + "var megaDict = {};\n";
programCode = programCode + "var megaString = \"FINAL_TEST_STRING\";\n";
programCode = programCode + "var megaNumber = 999999999.999999999;\n";
programCode = programCode + "var megaBoolean = true;\n";
programCode = programCode + "var megaNone = none;\n";
// Add complex nested structures
programCode = programCode + "for (var i = 0; i < 50; i = i + 1) {\n";
programCode = programCode + "var nestedArray = [];\n";
programCode = programCode + "var nestedDict = {};\n";
programCode = programCode + "for (var j = 0; j < 5; j = j + 1) {\n";
programCode = programCode + "push(nestedArray, \"nested_\" + toString(i) + \"_\" + toString(j));\n";
programCode = programCode + "nestedDict[\"key_\" + toString(i) + \"_\" + toString(j)] = \"value_\" + toString(i) + \"_\" + toString(j);\n";
programCode = programCode + "}\n";
programCode = programCode + "push(megaArray, nestedArray);\n";
programCode = programCode + "megaDict[\"dict_\" + toString(i)] = nestedDict;\n";
programCode = programCode + "}\n";
// Add function generation
programCode = programCode + "for (var funcIndex = 0; funcIndex < 10; funcIndex = funcIndex + 1) {\n";
programCode = programCode + "var funcName = \"megaFunc_\" + toString(funcIndex);\n";
programCode = programCode + "var funcCode = \"func \" + funcName + \"(a, b, c, d, e) { \";\n";
programCode = programCode + "funcCode = funcCode + \"var result = a + b * c - d / e; \";\n";
programCode = programCode + "funcCode = funcCode + \"if (result > 1000) { \";\n";
programCode = programCode + "funcCode = funcCode + \"return result * 2; \";\n";
programCode = programCode + "funcCode = funcCode + \"} else { \";\n";
programCode = programCode + "funcCode = funcCode + \"return result / 2; \";\n";
programCode = programCode + "funcCode = funcCode + \"} \";\n";
programCode = programCode + "funcCode = funcCode + \"} \";\n";
programCode = programCode + "eval(funcCode);\n";
programCode = programCode + "var testResult = eval(funcName + \"(10, 20, 30, 5, 2)\");\n";
programCode = programCode + "print(\"Generated and tested \" + funcName + \": \" + toString(testResult));\n";
programCode = programCode + "}\n";
// Add string indexing madness
programCode = programCode + "var complexString = \"Hello, Bob Language! This is a FINAL test with numbers 12345\";\n";
programCode = programCode + "var stringAnalysis = {};\n";
programCode = programCode + "for (var i = 0; i < len(complexString); i = i + 1) {\n";
programCode = programCode + "var char = complexString[i];\n";
programCode = programCode + "var charInfo = {};\n";
programCode = programCode + "charInfo[\"character\"] = char;\n";
programCode = programCode + "charInfo[\"index\"] = i;\n";
programCode = programCode + "charInfo[\"ascii_approx\"] = i * 2 + 32;\n";
programCode = programCode + "if (char == \" \") { charInfo[\"type\"] = \"space\"; }\n";
programCode = programCode + "else if (char == \",\" || char == \"!\") { charInfo[\"type\"] = \"symbol\"; }\n";
programCode = programCode + "else if (char == \"0\" || char == \"1\" || char == \"2\" || char == \"3\" || char == \"4\" || char == \"5\" || char == \"6\" || char == \"7\" || char == \"8\" || char == \"9\") { charInfo[\"type\"] = \"digit\"; }\n";
programCode = programCode + "else if (char == \"H\" || char == \"B\" || char == \"L\") { charInfo[\"type\"] = \"uppercase\"; }\n";
programCode = programCode + "else { charInfo[\"type\"] = \"lowercase\"; }\n";
programCode = programCode + "stringAnalysis[\"char_\" + toString(i)] = charInfo;\n";
programCode = programCode + "}\n";
// Add recursive function torture
programCode = programCode + "func megaRecursiveTorture(n, depth, accumulator) {\n";
programCode = programCode + "if (depth > 20) { return accumulator; }\n";
programCode = programCode + "var currentString = \"depth_\" + toString(depth) + \"_value_\" + toString(n);\n";
programCode = programCode + "var reversedString = \"\";\n";
programCode = programCode + "for (var i = len(currentString) - 1; i >= 0; i = i - 1) {\n";
programCode = programCode + "reversedString = reversedString + currentString[i];\n";
programCode = programCode + "}\n";
programCode = programCode + "var tempArray = [];\n";
programCode = programCode + "for (var i = 0; i < depth; i = i + 1) {\n";
programCode = programCode + "push(tempArray, reversedString + \"_\" + toString(i));\n";
programCode = programCode + "}\n";
programCode = programCode + "var tempDict = {};\n";
programCode = programCode + "tempDict[\"depth\"] = depth;\n";
programCode = programCode + "tempDict[\"value\"] = n;\n";
programCode = programCode + "tempDict[\"string\"] = currentString;\n";
programCode = programCode + "tempDict[\"reversed\"] = reversedString;\n";
programCode = programCode + "tempDict[\"array\"] = tempArray;\n";
programCode = programCode + "push(accumulator, tempDict);\n";
programCode = programCode + "return megaRecursiveTorture(n * 2 + depth, depth + 1, accumulator);\n";
programCode = programCode + "}\n";
programCode = programCode + "var recursiveResult = megaRecursiveTorture(1, 0, []);\n";
// Add mega array operations
programCode = programCode + "var megaArray2 = [];\n";
programCode = programCode + "var megaArray3 = [];\n";
programCode = programCode + "for (var i = 0; i < 100; i = i + 1) {\n";
programCode = programCode + "var complexValue = {};\n";
programCode = programCode + "complexValue[\"index\"] = i;\n";
programCode = programCode + "complexValue[\"square\"] = i * i;\n";
programCode = programCode + "complexValue[\"cube\"] = i * i * i;\n";
programCode = programCode + "complexValue[\"string\"] = \"value_\" + toString(i);\n";
programCode = programCode + "complexValue[\"array\"] = [i, i + 1, i + 2, i + 3, i + 4];\n";
programCode = programCode + "complexValue[\"dict\"] = {\"nested\": i, \"deep\": i * 2};\n";
programCode = programCode + "push(megaArray2, complexValue);\n";
programCode = programCode + "if (i % 2 == 0) { push(megaArray3, i * 2); } else { push(megaArray3, i * 3); }\n";
programCode = programCode + "}\n";
// Add mega eval torture
programCode = programCode + "for (var evalIndex = 0; evalIndex < 10; evalIndex = evalIndex + 1) {\n";
programCode = programCode + "var evalCode = \"var evalVar_\" + toString(evalIndex) + \" = \" + toString(evalIndex) + \" * \" + toString(evalIndex) + \" + \" + toString(evalIndex) + \";\";\n";
programCode = programCode + "evalCode = evalCode + \"var evalString_\" + toString(evalIndex) + \" = \\\"eval_string_\" + toString(evalIndex) + \"\\\";\";\n";
programCode = programCode + "evalCode = evalCode + \"var evalArray_\" + toString(evalIndex) + \" = [\" + toString(evalIndex) + \", \" + toString(evalIndex + 1) + \", \" + toString(evalIndex + 2) + \"];\";\n";
programCode = programCode + "evalCode = evalCode + \"var evalResult_\" + toString(evalIndex) + \" = evalVar_\" + toString(evalIndex) + \" + len(evalString_\" + toString(evalIndex) + \") + len(evalArray_\" + toString(evalIndex) + \");\";\n";
programCode = programCode + "evalCode = evalCode + \"evalResult_\" + toString(evalIndex);\n";
programCode = programCode + "var evalResult = eval(evalCode);\n";
programCode = programCode + "print(\"Eval torture progress: \" + toString(evalIndex) + \"/10\");\n";
programCode = programCode + "}\n";
// Add mega loop torture
programCode = programCode + "var loopResults = [];\n";
programCode = programCode + "var loopCounter = 0;\n";
programCode = programCode + "for (var i = 0; i < 10; i = i + 1) {\n";
programCode = programCode + "for (var j = 0; j < 5; j = j + 1) {\n";
programCode = programCode + "for (var k = 0; k < 5; k = k + 1) {\n";
programCode = programCode + "var loopValue = i * j * k;\n";
programCode = programCode + "var loopString = \"loop_\" + toString(i) + \"_\" + toString(j) + \"_\" + toString(k);\n";
programCode = programCode + "var reversedString = \"\";\n";
programCode = programCode + "for (var l = 0; l < len(loopString); l = l + 1) {\n";
programCode = programCode + "reversedString = reversedString + loopString[len(loopString) - 1 - l];\n";
programCode = programCode + "}\n";
programCode = programCode + "var loopObject = {\n";
programCode = programCode + "\"value\": loopValue,\n";
programCode = programCode + "\"string\": loopString,\n";
programCode = programCode + "\"reversed\": reversedString,\n";
programCode = programCode + "\"sum\": i + j + k\n";
programCode = programCode + "};\n";
programCode = programCode + "push(loopResults, loopObject);\n";
programCode = programCode + "loopCounter = loopCounter + 1;\n";
programCode = programCode + "}\n";
programCode = programCode + "}\n";
programCode = programCode + "}\n";
// Add final summary
programCode = programCode + "print(\"🎉 FINAL REGRESSION BUSTER COMPLETE!\");\n";
programCode = programCode + "print(\"✅ All phases completed successfully!\");\n";
programCode = programCode + "print(\"✅ Every feature tested against every other feature!\");\n";
programCode = programCode + "print(\"✅ Maximum complexity achieved!\");\n";
programCode = programCode + "print(\"✅ No regressions detected!\");\n";
programCode = programCode + "print(\"📊 FINAL STATISTICS:\");\n";
programCode = programCode + "print(\" • Variables created: 100+\");\n";
programCode = programCode + "print(\" • Functions generated: 10+\");\n";
programCode = programCode + "print(\" • Arrays processed: 500+ elements\");\n";
programCode = programCode + "print(\" • Dictionaries created: 100+ entries\");\n";
programCode = programCode + "print(\" • String characters processed: 100+\");\n";
programCode = programCode + "print(\" • Eval statements executed: 10+\");\n";
programCode = programCode + "print(\" • Loop iterations: 250+\");\n";
programCode = programCode + "print(\" • Conditional checks: 100+\");\n";
programCode = programCode + "print(\" • Arithmetic operations: 1000+\");\n";
programCode = programCode + "print(\" • Type conversions: 50+\");\n";
programCode = programCode + "print(\"🏆 FINAL REGRESSION TEST PASSED!\");\n";
programCode = programCode + "print(\"Bob is ROCK SOLID under maximum stress!\");\n";
programCode = programCode + "print(\"All features work perfectly together!\");\n";
programCode = programCode + "print(\"Ready for production use!\");\n";
programCode = programCode + "print(\"🚀 BOB IS UNSTOPPABLE! 🚀\");\n";
programCode = programCode + "print(\"🎊 FINAL REGRESSION BUSTER COMPLETE! 🎊\");\n";
// Write the program to a file
writeFile("final_regression_dynamic.bob", programCode);
print("✅ Complex program written to file: final_regression_dynamic.bob");
// ========================================
// PHASE 2: LOAD AND RUN THE PROGRAM
// ========================================
print("\n📂 PHASE 2: Loading and running the program...");
// Check if file exists
var fileExists = fileExists("final_regression_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
// Read the file content
var loadedCode = readFile("final_regression_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// Use eval to run the loaded code
print("\n⚡ PHASE 3: Executing program with eval...");
print("🚀 STARTING FINAL REGRESSION BUSTER...");
var evalResult = eval(loadedCode);
print("\n✅ PROGRAM EXECUTION COMPLETE!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire program!");
print("✅ All features tested successfully!");
} else {
print("❌ ERROR: File not found!");
}
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification...");
// Verify the file was created and has content
var verificationFile = readFile("final_regression_dynamic.bob");
var fileLength = len(verificationFile);
print(" Verification file length: " + toString(fileLength) + " characters");
print(" File contains complex program: " + toString(len(verificationFile) > 1000));
// Check for key elements in the file
var containsPrint = false;
var containsFunc = false;
var containsEval = false;
for (var i = 0; i < len(verificationFile); i = i + 1) {
var char = verificationFile[i];
if (char == "p" && i + 4 < len(verificationFile)) {
if (verificationFile[i + 1] == "r" && verificationFile[i + 2] == "i" && verificationFile[i + 3] == "n" && verificationFile[i + 4] == "t") {
containsPrint = true;
}
}
if (char == "f" && i + 3 < len(verificationFile)) {
if (verificationFile[i + 1] == "u" && verificationFile[i + 2] == "n" && verificationFile[i + 3] == "c") {
containsFunc = true;
}
}
if (char == "e" && i + 2 < len(verificationFile)) {
if (verificationFile[i + 1] == "v" && verificationFile[i + 2] == "a" && verificationFile[i + 3] == "l") {
containsEval = true;
}
}
}
print(" Contains print statements: " + toString(containsPrint));
print(" Contains function definitions: " + toString(containsFunc));
print(" Contains eval statements: " + toString(containsEval));
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 FINAL REGRESSION TEST COMPLETE!");
print("✅ Successfully wrote complex program to file");
print("✅ Successfully loaded file with file I/O");
print("✅ Successfully executed with eval");
print("✅ All features working together perfectly!");
print("\n🏆 FINAL TEST PASSED!");
print("Bob can write complex programs to files!");
print("Bob can read files with file I/O!");
print("Bob can execute loaded code with eval!");
print("Bob is UNSTOPPABLE!");
print("\n🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE! 🚀");
print("🎊 FINAL REGRESSION TEST COMPLETE! 🎊");

29
final_working_dynamic.bob
View File

@ -1,29 +0,0 @@
print("=== FINAL WORKING BUSTER ===");
print("Testing ALL features with working syntax...");
var testArray = [];
var testDict = {};
var testString = "Hello, Bob!";
var testNumber = 42;
var testBoolean = true;
for (var i = 0; i < 10; i = i + 1) {
push(testArray, i * i);
testDict["key_" + toString(i)] = i * 2;
}
print("String indexing test:");
for (var i = 0; i < len(testString); i = i + 1) {
print("Character " + toString(i) + ": " + testString[i]);
}
func testFunction(x, y) {
return x + y * 2;
}
var result = testFunction(5, 10);
print("Function result: " + toString(result));
var evalResult = eval("5 * 5 + 10");
print("Eval result: " + toString(evalResult));
print("✅ All core features working!");
print("✅ Arrays: " + toString(len(testArray)) + " elements");
print("✅ Dictionaries: " + toString(len(testDict)) + " entries");
print("✅ String indexing: " + toString(len(testString)) + " characters");
print("✅ Functions: working");
print("✅ Eval: working");
print("🎉 FINAL WORKING TEST PASSED!");

114
final_working_test.bob
View File

@ -1,114 +0,0 @@
print("=== FINAL WORKING TEST ===");
print("Creating a regression test that actually works...");
// ========================================
// PHASE 1: WRITE WORKING BOB CODE TO FILE
// ========================================
print("\n📝 PHASE 1: Writing working Bob code to file...");
// Create a properly formatted Bob program with correct syntax
var workingProgram = "print(\"=== FINAL WORKING BUSTER ===\");\n";
workingProgram = workingProgram + "print(\"Testing ALL features with working syntax...\");\n";
// Add basic variable declarations
workingProgram = workingProgram + "var testArray = [];\n";
workingProgram = workingProgram + "var testDict = {};\n";
workingProgram = workingProgram + "var testString = \"Hello, Bob!\";\n";
workingProgram = workingProgram + "var testNumber = 42;\n";
workingProgram = workingProgram + "var testBoolean = true;\n";
// Add array operations
workingProgram = workingProgram + "for (var i = 0; i < 10; i = i + 1) {\n";
workingProgram = workingProgram + " push(testArray, i * i);\n";
workingProgram = workingProgram + " testDict[\"key_\" + toString(i)] = i * 2;\n";
workingProgram = workingProgram + "}\n";
// Add string indexing
workingProgram = workingProgram + "print(\"String indexing test:\");\n";
workingProgram = workingProgram + "for (var i = 0; i < len(testString); i = i + 1) {\n";
workingProgram = workingProgram + " print(\"Character \" + toString(i) + \": \" + testString[i]);\n";
workingProgram = workingProgram + "}\n";
// Add function definition
workingProgram = workingProgram + "func testFunction(x, y) {\n";
workingProgram = workingProgram + " return x + y * 2;\n";
workingProgram = workingProgram + "}\n";
workingProgram = workingProgram + "var result = testFunction(5, 10);\n";
workingProgram = workingProgram + "print(\"Function result: \" + toString(result));\n";
// Add eval test
workingProgram = workingProgram + "var evalResult = eval(\"5 * 5 + 10\");\n";
workingProgram = workingProgram + "print(\"Eval result: \" + toString(evalResult));\n";
// Add final summary
workingProgram = workingProgram + "print(\"✅ All core features working!\");\n";
workingProgram = workingProgram + "print(\"✅ Arrays: \" + toString(len(testArray)) + \" elements\");\n";
workingProgram = workingProgram + "print(\"✅ Dictionaries: \" + toString(len(testDict)) + \" entries\");\n";
workingProgram = workingProgram + "print(\"✅ String indexing: \" + toString(len(testString)) + \" characters\");\n";
workingProgram = workingProgram + "print(\"✅ Functions: working\");\n";
workingProgram = workingProgram + "print(\"✅ Eval: working\");\n";
workingProgram = workingProgram + "print(\"🎉 FINAL WORKING TEST PASSED!\");\n";
// Write the working program to a file
writeFile("final_working_dynamic.bob", workingProgram);
print("✅ Working Bob code written to file: final_working_dynamic.bob");
// ========================================
// PHASE 2: LOAD AND RUN THE WORKING PROGRAM
// ========================================
print("\n📂 PHASE 2: Loading and running the working program...");
// Check if file exists
var fileExists = fileExists("final_working_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
// Read the file content
var loadedCode = readFile("final_working_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// Use eval to run the loaded code
print("\n⚡ PHASE 3: Executing working program with eval...");
print("🚀 STARTING FINAL WORKING BUSTER...");
var evalResult = eval(loadedCode);
print("\n✅ PROGRAM EXECUTION COMPLETE!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire program!");
print("✅ All features tested successfully!");
} else {
print("❌ ERROR: File not found!");
}
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification...");
// Verify the file was created and has content
var verificationFile = readFile("final_working_dynamic.bob");
var fileLength = len(verificationFile);
print(" Verification file length: " + toString(fileLength) + " characters");
print(" File contains working program: " + toString(len(verificationFile) > 100));
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 FINAL WORKING TEST COMPLETE!");
print("✅ Successfully wrote working Bob code to file");
print("✅ Successfully loaded file with file I/O");
print("✅ Successfully executed with eval");
print("✅ All features working together perfectly!");
print("\n🏆 FINAL WORKING TEST PASSED!");
print("Bob can write working programs to files!");
print("Bob can read files with file I/O!");
print("Bob can execute loaded code with eval!");
print("Bob is UNSTOPPABLE!");
print("\n🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE! 🚀");
print("🎊 FINAL WORKING TEST COMPLETE! 🎊");

3
fix_test.bob
View File

@ -1,3 +0,0 @@
print("Hello World");
var x = 5;
print("x = " + toString(x));

29
fixed_regression_dynamic.bob
View File

@ -1,29 +0,0 @@
print("=== FIXED REGRESSION BUSTER ===");
print("Testing ALL features with proper syntax...");
var testArray = [];
var testDict = {};
var testString = "Hello, Bob!";
var testNumber = 42;
var testBoolean = true;
for (var i = 0; i < 10; i = i + 1) {
push(testArray, i * i);
testDict["key_" + toString(i)] = i * 2;
}
print("String indexing test:");
for (var i = 0; i < len(testString); i = i + 1) {
print("Character " + toString(i) + ": " + testString[i]);
}
func testFunction(x, y) {
return x + y * 2;
}
var result = testFunction(5, 10);
print("Function result: " + toString(result));
var evalResult = eval("5 * 5 + 10");
print("Eval result: " + toString(evalResult));
print("✅ All core features working!");
print("✅ Arrays: " + toString(len(testArray)) + " elements");
print("✅ Dictionaries: " + toString(len(testDict)) + " entries");
print("✅ String indexing: " + toString(len(testString)) + " characters");
print("✅ Functions: working");
print("✅ Eval: working");
print("🎉 FIXED REGRESSION TEST PASSED!");

150
fixed_regression_test.bob
View File

@ -1,150 +0,0 @@
print("=== FIXED REGRESSION TEST ===");
print("Generating valid Bob code with proper syntax...");
// ========================================
// PHASE 1: WRITE VALID BOB CODE TO FILE
// ========================================
print("\n📝 PHASE 1: Writing valid Bob code to file...");
// Create a properly formatted Bob program with correct syntax
var validProgram = "print(\"=== FIXED REGRESSION BUSTER ===\");\n";
validProgram = validProgram + "print(\"Testing ALL features with proper syntax...\");\n";
// Add basic variable declarations with proper semicolons
validProgram = validProgram + "var testArray = [];\n";
validProgram = validProgram + "var testDict = {};\n";
validProgram = validProgram + "var testString = \"Hello, Bob!\";\n";
validProgram = validProgram + "var testNumber = 42;\n";
validProgram = validProgram + "var testBoolean = true;\n";
// Add array operations with proper syntax
validProgram = validProgram + "for (var i = 0; i < 10; i = i + 1) {\n";
validProgram = validProgram + " push(testArray, i * i);\n";
validProgram = validProgram + " testDict[\"key_\" + toString(i)] = i * 2;\n";
validProgram = validProgram + "}\n";
// Add string indexing with proper syntax
validProgram = validProgram + "print(\"String indexing test:\");\n";
validProgram = validProgram + "for (var i = 0; i < len(testString); i = i + 1) {\n";
validProgram = validProgram + " print(\"Character \" + toString(i) + \": \" + testString[i]);\n";
validProgram = validProgram + "}\n";
// Add function definition with proper syntax
validProgram = validProgram + "func testFunction(x, y) {\n";
validProgram = validProgram + " return x + y * 2;\n";
validProgram = validProgram + "}\n";
validProgram = validProgram + "var result = testFunction(5, 10);\n";
validProgram = validProgram + "print(\"Function result: \" + toString(result));\n";
// Add eval test with proper syntax
validProgram = validProgram + "var evalResult = eval(\"5 * 5 + 10\");\n";
validProgram = validProgram + "print(\"Eval result: \" + toString(evalResult));\n";
// Add final summary with proper syntax
validProgram = validProgram + "print(\"✅ All core features working!\");\n";
validProgram = validProgram + "print(\"✅ Arrays: \" + toString(len(testArray)) + \" elements\");\n";
validProgram = validProgram + "print(\"✅ Dictionaries: \" + toString(len(testDict)) + \" entries\");\n";
validProgram = validProgram + "print(\"✅ String indexing: \" + toString(len(testString)) + \" characters\");\n";
validProgram = validProgram + "print(\"✅ Functions: working\");\n";
validProgram = validProgram + "print(\"✅ Eval: working\");\n";
validProgram = validProgram + "print(\"🎉 FIXED REGRESSION TEST PASSED!\");\n";
// Write the valid program to a file
writeFile("fixed_regression_dynamic.bob", validProgram);
print("✅ Valid Bob code written to file: fixed_regression_dynamic.bob");
// ========================================
// PHASE 2: LOAD AND RUN THE VALID PROGRAM
// ========================================
print("\n📂 PHASE 2: Loading and running the valid program...");
// Check if file exists
var fileExists = fileExists("fixed_regression_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
// Read the file content
var loadedCode = readFile("fixed_regression_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// Use eval to run the loaded code
print("\n⚡ PHASE 3: Executing valid program with eval...");
print("🚀 STARTING FIXED REGRESSION BUSTER...");
var evalResult = eval(loadedCode);
print("\n✅ PROGRAM EXECUTION COMPLETE!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire program!");
print("✅ All features tested successfully!");
} else {
print("❌ ERROR: File not found!");
}
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification...");
// Verify the file was created and has content
var verificationFile = readFile("fixed_regression_dynamic.bob");
var fileLength = len(verificationFile);
print(" Verification file length: " + toString(fileLength) + " characters");
print(" File contains valid program: " + toString(len(verificationFile) > 100));
// Check for key elements in the file
var containsPrint = false;
var containsFunc = false;
var containsEval = false;
for (var i = 0; i < len(verificationFile); i = i + 1) {
var char = verificationFile[i];
if (char == "p" && i + 4 < len(verificationFile)) {
if (verificationFile[i + 1] == "r" && verificationFile[i + 2] == "i" && verificationFile[i + 3] == "n" && verificationFile[i + 4] == "t") {
containsPrint = true;
}
}
if (char == "f" && i + 3 < len(verificationFile)) {
if (verificationFile[i + 1] == "u" && verificationFile[i + 2] == "n" && verificationFile[i + 3] == "c") {
containsFunc = true;
}
}
if (char == "e" && i + 2 < len(verificationFile)) {
if (verificationFile[i + 1] == "v" && verificationFile[i + 2] == "a" && verificationFile[i + 3] == "l") {
containsEval = true;
}
}
}
print(" Contains print statements: " + toString(containsPrint));
print(" Contains function definitions: " + toString(containsFunc));
print(" Contains eval statements: " + toString(containsEval));
// ========================================
// PHASE 5: TEST DIRECT EXECUTION
// ========================================
print("\n🎯 PHASE 5: Testing direct execution...");
// Test that the generated file can be executed directly
print(" Testing direct execution of generated file...");
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 FIXED REGRESSION TEST COMPLETE!");
print("✅ Successfully wrote valid Bob code to file");
print("✅ Successfully loaded file with file I/O");
print("✅ Successfully executed with eval");
print("✅ All features working together perfectly!");
print("\n🏆 FIXED TEST PASSED!");
print("Bob can write valid programs to files!");
print("Bob can read files with file I/O!");
print("Bob can execute loaded code with eval!");
print("Bob is UNSTOPPABLE!");
print("\n🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE! 🚀");
print("🎊 FIXED REGRESSION TEST COMPLETE! 🎊");

2
hello.txt
View File

@ -1,2 +0,0 @@
Hello, Bob!
This is a test file.

136
insane_regression_dynamic.bob
View File

@ -1,136 +0,0 @@
print("=== INSANE REGRESSION BUSTER ===");
print("Testing ALL features together...");
var megaArray = [];
var megaDict = {};
var megaString = "INSANE_TEST_STRING";
var megaNumber = 999999999.999999999;
var megaBoolean = true;
var megaNone = none;
for (var i = 0; i < 100; i = i + 1) {
var nestedArray = [];
var nestedDict = {};
for (var j = 0; j < 10; j = j + 1) {
push(nestedArray, "nested_" + toString(i) + "_" + toString(j));
nestedDict["key_" + toString(i) + "_" + toString(j)] = "value_" + toString(i) + "_" + toString(j);
}
push(megaArray, nestedArray);
megaDict["dict_" + toString(i)] = nestedDict;
}
for (var funcIndex = 0; funcIndex < 50; funcIndex = funcIndex + 1) {
var funcName = "megaFunc_" + toString(funcIndex);
var funcCode = "func " + funcName + "(a, b, c, d, e) { ";
funcCode = funcCode + "var result = a + b * c - d / e; ";
funcCode = funcCode + "if (result > 1000) { ";
funcCode = funcCode + "return result * 2; ";
funcCode = funcCode + "} else { ";
funcCode = funcCode + "return result / 2; ";
funcCode = funcCode + "} ";
funcCode = funcCode + "} ";
eval(funcCode);
var testResult = eval(funcName + "(10, 20, 30, 5, 2)");
print("Generated and tested " + funcName + ": " + toString(testResult));
}
var complexString = "Hello, Bob Language! This is a INSANE test with numbers 12345";
var stringAnalysis = {};
for (var i = 0; i < len(complexString); i = i + 1) {
var char = complexString[i];
var charInfo = {};
charInfo["character"] = char;
charInfo["index"] = i;
charInfo["ascii_approx"] = i * 2 + 32;
if (char == " ") { charInfo["type"] = "space"; }
else if (char == "," || char == "!") { charInfo["type"] = "symbol"; }
else if (char == "0" || char == "1" || char == "2" || char == "3" || char == "4" || char == "5" || char == "6" || char == "7" || char == "8" || char == "9") { charInfo["type"] = "digit"; }
else if (char == "H" || char == "B" || char == "L") { charInfo["type"] = "uppercase"; }
else { charInfo["type"] = "lowercase"; }
stringAnalysis["char_" + toString(i)] = charInfo;
}
func megaRecursiveTorture(n, depth, accumulator) {
if (depth > 50) { return accumulator; }
var currentString = "depth_" + toString(depth) + "_value_" + toString(n);
var reversedString = "";
for (var i = len(currentString) - 1; i >= 0; i = i - 1) {
reversedString = reversedString + currentString[i];
}
var tempArray = [];
for (var i = 0; i < depth; i = i + 1) {
push(tempArray, reversedString + "_" + toString(i));
}
var tempDict = {};
tempDict["depth"] = depth;
tempDict["value"] = n;
tempDict["string"] = currentString;
tempDict["reversed"] = reversedString;
tempDict["array"] = tempArray;
push(accumulator, tempDict);
return megaRecursiveTorture(n * 2 + depth, depth + 1, accumulator);
}
var recursiveResult = megaRecursiveTorture(1, 0, []);
var megaArray2 = [];
var megaArray3 = [];
for (var i = 0; i < 1000; i = i + 1) {
var complexValue = {};
complexValue["index"] = i;
complexValue["square"] = i * i;
complexValue["cube"] = i * i * i;
complexValue["string"] = "value_" + toString(i);
complexValue["array"] = [i, i + 1, i + 2, i + 3, i + 4];
complexValue["dict"] = {"nested": i, "deep": i * 2};
push(megaArray2, complexValue);
if (i % 2 == 0) { push(megaArray3, i * 2); } else { push(megaArray3, i * 3); }
}
for (var evalIndex = 0; evalIndex < 100; evalIndex = evalIndex + 1) {
var evalCode = "var evalVar_" + toString(evalIndex) + " = " + toString(evalIndex) + " * " + toString(evalIndex) + " + " + toString(evalIndex) + ";";
evalCode = evalCode + "var evalString_" + toString(evalIndex) + " = \"eval_string_" + toString(evalIndex) + "\";";
evalCode = evalCode + "var evalArray_" + toString(evalIndex) + " = [" + toString(evalIndex) + ", " + toString(evalIndex + 1) + ", " + toString(evalIndex + 2) + "];";
evalCode = evalCode + "var evalResult_" + toString(evalIndex) + " = evalVar_" + toString(evalIndex) + " + len(evalString_" + toString(evalIndex) + ") + len(evalArray_" + toString(evalIndex) + ");";
evalCode = evalCode + "evalResult_" + toString(evalIndex);
var evalResult = eval(evalCode);
if (evalIndex % 10 == 0) {
print("Eval torture progress: " + toString(evalIndex) + "/100");
}
}
var loopResults = [];
var loopCounter = 0;
for (var i = 0; i < 100; i = i + 1) {
for (var j = 0; j < 50; j = j + 1) {
for (var k = 0; k < 25; k = k + 1) {
var loopValue = i * j * k;
var loopString = "loop_" + toString(i) + "_" + toString(j) + "_" + toString(k);
var reversedString = "";
for (var l = 0; l < len(loopString); l = l + 1) {
reversedString = reversedString + loopString[len(loopString) - 1 - l];
}
var loopObject = {
"value": loopValue,
"string": loopString,
"reversed": reversedString,
"sum": i + j + k
};
push(loopResults, loopObject);
loopCounter = loopCounter + 1;
}
}
}
print("🎉 INSANE REGRESSION BUSTER COMPLETE!");
print("✅ All phases completed successfully!");
print("✅ Every feature tested against every other feature!");
print("✅ Maximum complexity achieved!");
print("✅ No regressions detected!");
print("📊 FINAL STATISTICS:");
print(" • Variables created: 1000+");
print(" • Functions generated: 50+");
print(" • Arrays processed: 5000+ elements");
print(" • Dictionaries created: 1000+ entries");
print(" • String characters processed: 1000+");
print(" • Eval statements executed: 100+");
print(" • Loop iterations: 125,000+");
print(" • Conditional checks: 1000+");
print(" • Arithmetic operations: 10,000+");
print(" • Type conversions: 500+");
print("🏆 INSANE REGRESSION TEST PASSED!");
print("Bob is ROCK SOLID under maximum stress!");
print("All features work perfectly together!");
print("Ready for production use!");
print("🚀 BOB IS UNSTOPPABLE! 🚀");
print("🎊 INSANE REGRESSION BUSTER COMPLETE! 🎊");

254
insane_regression_test.bob
View File

@ -1,254 +0,0 @@
print("=== INSANE REGRESSION TEST ===");
print("Writing complex program to file, then loading and running it...");
// ========================================
// PHASE 1: WRITE COMPLEX PROGRAM TO FILE
// ========================================
print("\n📝 PHASE 1: Writing complex program to file...");
var programCode = "print(\"=== INSANE REGRESSION BUSTER ===\");\n";
programCode = programCode + "print(\"Testing ALL features together...\");\n";
// Add massive variable declarations
programCode = programCode + "var megaArray = [];\n";
programCode = programCode + "var megaDict = {};\n";
programCode = programCode + "var megaString = \"INSANE_TEST_STRING\";\n";
programCode = programCode + "var megaNumber = 999999999.999999999;\n";
programCode = programCode + "var megaBoolean = true;\n";
programCode = programCode + "var megaNone = none;\n";
// Add complex nested structures
programCode = programCode + "for (var i = 0; i < 100; i = i + 1) {\n";
programCode = programCode + "var nestedArray = [];\n";
programCode = programCode + "var nestedDict = {};\n";
programCode = programCode + "for (var j = 0; j < 10; j = j + 1) {\n";
programCode = programCode + "push(nestedArray, \"nested_\" + toString(i) + \"_\" + toString(j));\n";
programCode = programCode + "nestedDict[\"key_\" + toString(i) + \"_\" + toString(j)] = \"value_\" + toString(i) + \"_\" + toString(j);\n";
programCode = programCode + "}\n";
programCode = programCode + "push(megaArray, nestedArray);\n";
programCode = programCode + "megaDict[\"dict_\" + toString(i)] = nestedDict;\n";
programCode = programCode + "}\n";
// Add function generation
programCode = programCode + "for (var funcIndex = 0; funcIndex < 50; funcIndex = funcIndex + 1) {\n";
programCode = programCode + "var funcName = \"megaFunc_\" + toString(funcIndex);\n";
programCode = programCode + "var funcCode = \"func \" + funcName + \"(a, b, c, d, e) { \";\n";
programCode = programCode + "funcCode = funcCode + \"var result = a + b * c - d / e; \";\n";
programCode = programCode + "funcCode = funcCode + \"if (result > 1000) { \";\n";
programCode = programCode + "funcCode = funcCode + \"return result * 2; \";\n";
programCode = programCode + "funcCode = funcCode + \"} else { \";\n";
programCode = programCode + "funcCode = funcCode + \"return result / 2; \";\n";
programCode = programCode + "funcCode = funcCode + \"} \";\n";
programCode = programCode + "funcCode = funcCode + \"} \";\n";
programCode = programCode + "eval(funcCode);\n";
programCode = programCode + "var testResult = eval(funcName + \"(10, 20, 30, 5, 2)\");\n";
programCode = programCode + "print(\"Generated and tested \" + funcName + \": \" + toString(testResult));\n";
programCode = programCode + "}\n";
// Add string indexing madness
programCode = programCode + "var complexString = \"Hello, Bob Language! This is a INSANE test with numbers 12345\";\n";
programCode = programCode + "var stringAnalysis = {};\n";
programCode = programCode + "for (var i = 0; i < len(complexString); i = i + 1) {\n";
programCode = programCode + "var char = complexString[i];\n";
programCode = programCode + "var charInfo = {};\n";
programCode = programCode + "charInfo[\"character\"] = char;\n";
programCode = programCode + "charInfo[\"index\"] = i;\n";
programCode = programCode + "charInfo[\"ascii_approx\"] = i * 2 + 32;\n";
programCode = programCode + "if (char == \" \") { charInfo[\"type\"] = \"space\"; }\n";
programCode = programCode + "else if (char == \",\" || char == \"!\") { charInfo[\"type\"] = \"symbol\"; }\n";
programCode = programCode + "else if (char == \"0\" || char == \"1\" || char == \"2\" || char == \"3\" || char == \"4\" || char == \"5\" || char == \"6\" || char == \"7\" || char == \"8\" || char == \"9\") { charInfo[\"type\"] = \"digit\"; }\n";
programCode = programCode + "else if (char == \"H\" || char == \"B\" || char == \"L\") { charInfo[\"type\"] = \"uppercase\"; }\n";
programCode = programCode + "else { charInfo[\"type\"] = \"lowercase\"; }\n";
programCode = programCode + "stringAnalysis[\"char_\" + toString(i)] = charInfo;\n";
programCode = programCode + "}\n";
// Add recursive function torture
programCode = programCode + "func megaRecursiveTorture(n, depth, accumulator) {\n";
programCode = programCode + "if (depth > 50) { return accumulator; }\n";
programCode = programCode + "var currentString = \"depth_\" + toString(depth) + \"_value_\" + toString(n);\n";
programCode = programCode + "var reversedString = \"\";\n";
programCode = programCode + "for (var i = len(currentString) - 1; i >= 0; i = i - 1) {\n";
programCode = programCode + "reversedString = reversedString + currentString[i];\n";
programCode = programCode + "}\n";
programCode = programCode + "var tempArray = [];\n";
programCode = programCode + "for (var i = 0; i < depth; i = i + 1) {\n";
programCode = programCode + "push(tempArray, reversedString + \"_\" + toString(i));\n";
programCode = programCode + "}\n";
programCode = programCode + "var tempDict = {};\n";
programCode = programCode + "tempDict[\"depth\"] = depth;\n";
programCode = programCode + "tempDict[\"value\"] = n;\n";
programCode = programCode + "tempDict[\"string\"] = currentString;\n";
programCode = programCode + "tempDict[\"reversed\"] = reversedString;\n";
programCode = programCode + "tempDict[\"array\"] = tempArray;\n";
programCode = programCode + "push(accumulator, tempDict);\n";
programCode = programCode + "return megaRecursiveTorture(n * 2 + depth, depth + 1, accumulator);\n";
programCode = programCode + "}\n";
programCode = programCode + "var recursiveResult = megaRecursiveTorture(1, 0, []);\n";
// Add mega array operations
programCode = programCode + "var megaArray2 = [];\n";
programCode = programCode + "var megaArray3 = [];\n";
programCode = programCode + "for (var i = 0; i < 1000; i = i + 1) {\n";
programCode = programCode + "var complexValue = {};\n";
programCode = programCode + "complexValue[\"index\"] = i;\n";
programCode = programCode + "complexValue[\"square\"] = i * i;\n";
programCode = programCode + "complexValue[\"cube\"] = i * i * i;\n";
programCode = programCode + "complexValue[\"string\"] = \"value_\" + toString(i);\n";
programCode = programCode + "complexValue[\"array\"] = [i, i + 1, i + 2, i + 3, i + 4];\n";
programCode = programCode + "complexValue[\"dict\"] = {\"nested\": i, \"deep\": i * 2};\n";
programCode = programCode + "push(megaArray2, complexValue);\n";
programCode = programCode + "if (i % 2 == 0) { push(megaArray3, i * 2); } else { push(megaArray3, i * 3); }\n";
programCode = programCode + "}\n";
// Add mega eval torture
programCode = programCode + "for (var evalIndex = 0; evalIndex < 100; evalIndex = evalIndex + 1) {\n";
programCode = programCode + "var evalCode = \"var evalVar_\" + toString(evalIndex) + \" = \" + toString(evalIndex) + \" * \" + toString(evalIndex) + \" + \" + toString(evalIndex) + \";\";\n";
programCode = programCode + "evalCode = evalCode + \"var evalString_\" + toString(evalIndex) + \" = \\\"eval_string_\" + toString(evalIndex) + \"\\\";\";\n";
programCode = programCode + "evalCode = evalCode + \"var evalArray_\" + toString(evalIndex) + \" = [\" + toString(evalIndex) + \", \" + toString(evalIndex + 1) + \", \" + toString(evalIndex + 2) + \"];\";\n";
programCode = programCode + "evalCode = evalCode + \"var evalResult_\" + toString(evalIndex) + \" = evalVar_\" + toString(evalIndex) + \" + len(evalString_\" + toString(evalIndex) + \") + len(evalArray_\" + toString(evalIndex) + \");\";\n";
programCode = programCode + "evalCode = evalCode + \"evalResult_\" + toString(evalIndex);\n";
programCode = programCode + "var evalResult = eval(evalCode);\n";
programCode = programCode + "if (evalIndex % 10 == 0) {\n";
programCode = programCode + "print(\"Eval torture progress: \" + toString(evalIndex) + \"/100\");\n";
programCode = programCode + "}\n";
programCode = programCode + "}\n";
// Add mega loop torture
programCode = programCode + "var loopResults = [];\n";
programCode = programCode + "var loopCounter = 0;\n";
programCode = programCode + "for (var i = 0; i < 100; i = i + 1) {\n";
programCode = programCode + "for (var j = 0; j < 50; j = j + 1) {\n";
programCode = programCode + "for (var k = 0; k < 25; k = k + 1) {\n";
programCode = programCode + "var loopValue = i * j * k;\n";
programCode = programCode + "var loopString = \"loop_\" + toString(i) + \"_\" + toString(j) + \"_\" + toString(k);\n";
programCode = programCode + "var reversedString = \"\";\n";
programCode = programCode + "for (var l = 0; l < len(loopString); l = l + 1) {\n";
programCode = programCode + "reversedString = reversedString + loopString[len(loopString) - 1 - l];\n";
programCode = programCode + "}\n";
programCode = programCode + "var loopObject = {\n";
programCode = programCode + "\"value\": loopValue,\n";
programCode = programCode + "\"string\": loopString,\n";
programCode = programCode + "\"reversed\": reversedString,\n";
programCode = programCode + "\"sum\": i + j + k\n";
programCode = programCode + "};\n";
programCode = programCode + "push(loopResults, loopObject);\n";
programCode = programCode + "loopCounter = loopCounter + 1;\n";
programCode = programCode + "}\n";
programCode = programCode + "}\n";
programCode = programCode + "}\n";
// Add final summary
programCode = programCode + "print(\"🎉 INSANE REGRESSION BUSTER COMPLETE!\");\n";
programCode = programCode + "print(\"✅ All phases completed successfully!\");\n";
programCode = programCode + "print(\"✅ Every feature tested against every other feature!\");\n";
programCode = programCode + "print(\"✅ Maximum complexity achieved!\");\n";
programCode = programCode + "print(\"✅ No regressions detected!\");\n";
programCode = programCode + "print(\"📊 FINAL STATISTICS:\");\n";
programCode = programCode + "print(\" • Variables created: 1000+\");\n";
programCode = programCode + "print(\" • Functions generated: 50+\");\n";
programCode = programCode + "print(\" • Arrays processed: 5000+ elements\");\n";
programCode = programCode + "print(\" • Dictionaries created: 1000+ entries\");\n";
programCode = programCode + "print(\" • String characters processed: 1000+\");\n";
programCode = programCode + "print(\" • Eval statements executed: 100+\");\n";
programCode = programCode + "print(\" • Loop iterations: 125,000+\");\n";
programCode = programCode + "print(\" • Conditional checks: 1000+\");\n";
programCode = programCode + "print(\" • Arithmetic operations: 10,000+\");\n";
programCode = programCode + "print(\" • Type conversions: 500+\");\n";
programCode = programCode + "print(\"🏆 INSANE REGRESSION TEST PASSED!\");\n";
programCode = programCode + "print(\"Bob is ROCK SOLID under maximum stress!\");\n";
programCode = programCode + "print(\"All features work perfectly together!\");\n";
programCode = programCode + "print(\"Ready for production use!\");\n";
programCode = programCode + "print(\"🚀 BOB IS UNSTOPPABLE! 🚀\");\n";
programCode = programCode + "print(\"🎊 INSANE REGRESSION BUSTER COMPLETE! 🎊\");\n";
// Write the program to a file
writeFile("insane_regression_dynamic.bob", programCode);
print("✅ Complex program written to file: insane_regression_dynamic.bob");
// ========================================
// PHASE 2: LOAD AND RUN THE PROGRAM
// ========================================
print("\n📂 PHASE 2: Loading and running the program...");
// Check if file exists
var fileExists = fileExists("insane_regression_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
// Read the file content
var loadedCode = readFile("insane_regression_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// Use eval to run the loaded code
print("\n⚡ PHASE 3: Executing program with eval...");
print("🚀 STARTING INSANE REGRESSION BUSTER...");
var evalResult = eval(loadedCode);
print("\n✅ PROGRAM EXECUTION COMPLETE!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire program!");
print("✅ All features tested successfully!");
} else {
print("❌ ERROR: File not found!");
}
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification...");
// Verify the file was created and has content
var verificationFile = readFile("insane_regression_dynamic.bob");
var fileLength = len(verificationFile);
print(" Verification file length: " + toString(fileLength) + " characters");
print(" File contains complex program: " + toString(len(verificationFile) > 1000));
// Check for key elements in the file
var containsPrint = false;
var containsFunc = false;
var containsEval = false;
for (var i = 0; i < len(verificationFile); i = i + 1) {
var char = verificationFile[i];
if (char == "p" && i + 4 < len(verificationFile)) {
if (verificationFile[i + 1] == "r" && verificationFile[i + 2] == "i" && verificationFile[i + 3] == "n" && verificationFile[i + 4] == "t") {
containsPrint = true;
}
}
if (char == "f" && i + 3 < len(verificationFile)) {
if (verificationFile[i + 1] == "u" && verificationFile[i + 2] == "n" && verificationFile[i + 3] == "c") {
containsFunc = true;
}
}
if (char == "e" && i + 2 < len(verificationFile)) {
if (verificationFile[i + 1] == "v" && verificationFile[i + 2] == "a" && verificationFile[i + 3] == "l") {
containsEval = true;
}
}
}
print(" Contains print statements: " + toString(containsPrint));
print(" Contains function definitions: " + toString(containsFunc));
print(" Contains eval statements: " + toString(containsEval));
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 INSANE REGRESSION TEST COMPLETE!");
print("✅ Successfully wrote complex program to file");
print("✅ Successfully loaded file with file I/O");
print("✅ Successfully executed with eval");
print("✅ All features working together perfectly!");
print("\n🏆 INSANE TEST PASSED!");
print("Bob can write complex programs to files!");
print("Bob can read files with file I/O!");
print("Bob can execute loaded code with eval!");
print("Bob is UNSTOPPABLE!");
print("\n🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE! 🚀");
print("🎊 INSANE REGRESSION TEST COMPLETE! 🎊");

100
large.txt
View File

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

274
mega_loader.bob
View File

@ -1,274 +0,0 @@
print("=== MEGA REGRESSION LOADER ===");
print("Writing mega program to file, then loading and running it...");
// ========================================
// PHASE 1: WRITE MEGA PROGRAM TO FILE
// ========================================
print("\n📝 PHASE 1: Writing mega program to file...");
var megaProgramCode = "print(\"=== MEGA REGRESSION BUSTER 9000 ===\");";
megaProgramCode = megaProgramCode + "print(\"Testing EVERY feature against EVERY other feature...\");";
// Add the entire mega program as a string
megaProgramCode = megaProgramCode + "var megaArray = [];";
megaProgramCode = megaProgramCode + "var megaDict = {};";
megaProgramCode = megaProgramCode + "var megaString = \"MEGA_REGRESSION_TEST_STRING_WITH_SPECIAL_CHARS_!@#$%^&*()_+-=[]{}|;':\\\",./<>?\";";
megaProgramCode = megaProgramCode + "var megaNumber = 999999999.999999999;";
megaProgramCode = megaProgramCode + "var megaBoolean = true;";
megaProgramCode = megaProgramCode + "var megaNone = none;";
// Add complex nested structures
megaProgramCode = megaProgramCode + 'for (var i = 0; i < 100; i = i + 1) {';
megaProgramCode = megaProgramCode + 'var nestedArray = [];';
megaProgramCode = megaProgramCode + 'var nestedDict = {};';
megaProgramCode = megaProgramCode + 'for (var j = 0; j < 10; j = j + 1) {';
megaProgramCode = megaProgramCode + 'push(nestedArray, "nested_" + toString(i) + "_" + toString(j));';
megaProgramCode = megaProgramCode + 'nestedDict["key_" + toString(i) + "_" + toString(j)] = "value_" + toString(i) + "_" + toString(j);';
megaProgramCode = megaProgramCode + '}';
megaProgramCode = megaProgramCode + 'push(megaArray, nestedArray);';
megaProgramCode = megaProgramCode + 'megaDict["dict_" + toString(i)] = nestedDict;';
megaProgramCode = megaProgramCode + '}';
// Add function generation
megaProgramCode = megaProgramCode + 'for (var funcIndex = 0; funcIndex < 50; funcIndex = funcIndex + 1) {';
megaProgramCode = megaProgramCode + 'var funcName = "megaFunc_" + toString(funcIndex);';
megaProgramCode = megaProgramCode + 'var funcCode = "func " + funcName + "(a, b, c, d, e) { ";';
megaProgramCode = megaProgramCode + 'funcCode = funcCode + "var result = a + b * c - d / e; ";';
megaProgramCode = megaProgramCode + 'funcCode = funcCode + "if (result > 1000) { ";';
megaProgramCode = megaProgramCode + 'funcCode = funcCode + "return result * 2; ";';
megaProgramCode = megaProgramCode + 'funcCode = funcCode + "} else { ";';
megaProgramCode = megaProgramCode + 'funcCode = funcCode + "return result / 2; ";';
megaProgramCode = megaProgramCode + 'funcCode = funcCode + "} ";';
megaProgramCode = megaProgramCode + 'funcCode = funcCode + "}";';
megaProgramCode = megaProgramCode + 'eval(funcCode);';
megaProgramCode = megaProgramCode + 'var testResult = eval(funcName + "(10, 20, 30, 5, 2)");';
megaProgramCode = megaProgramCode + 'print("Generated and tested " + funcName + ": " + toString(testResult));';
megaProgramCode = megaProgramCode + '}';
// Add string indexing madness
megaProgramCode = megaProgramCode + 'var complexString = "Hello, Bob Language! This is a MEGA test with numbers 12345 and symbols !@#$%^&*()";';
megaProgramCode = megaProgramCode + 'var stringAnalysis = {};';
megaProgramCode = megaProgramCode + 'for (var i = 0; i < len(complexString); i = i + 1) {';
megaProgramCode = megaProgramCode + 'var char = complexString[i];';
megaProgramCode = megaProgramCode + 'var charInfo = {};';
megaProgramCode = megaProgramCode + 'charInfo["character"] = char;';
megaProgramCode = megaProgramCode + 'charInfo["index"] = i;';
megaProgramCode = megaProgramCode + 'charInfo["ascii_approx"] = i * 2 + 32;';
megaProgramCode = megaProgramCode + 'if (char == " ") { charInfo["type"] = "space"; }';
megaProgramCode = megaProgramCode + 'else if (char == "," || char == "!" || char == "@" || char == "#" || char == "$" || char == "%" || char == "^" || char == "&" || char == "*" || char == "(" || char == ")") { charInfo["type"] = "symbol"; }';
megaProgramCode = megaProgramCode + 'else if (char == "0" || char == "1" || char == "2" || char == "3" || char == "4" || char == "5" || char == "6" || char == "7" || char == "8" || char == "9") { charInfo["type"] = "digit"; }';
megaProgramCode = megaProgramCode + 'else if (char == "H" || char == "B" || char == "L" || char == "M" || char == "E" || char == "G" || char == "A" || char == "T") { charInfo["type"] = "uppercase"; }';
megaProgramCode = megaProgramCode + 'else { charInfo["type"] = "lowercase"; }';
megaProgramCode = megaProgramCode + 'stringAnalysis["char_" + toString(i)] = charInfo;';
megaProgramCode = megaProgramCode + '}';
// Add recursive function torture
megaProgramCode = megaProgramCode + 'func megaRecursiveTorture(n, depth, accumulator) {';
megaProgramCode = megaProgramCode + 'if (depth > 50) { return accumulator; }';
megaProgramCode = megaProgramCode + 'var currentString = "depth_" + toString(depth) + "_value_" + toString(n);';
megaProgramCode = megaProgramCode + 'var reversedString = "";';
megaProgramCode = megaProgramCode + 'for (var i = len(currentString) - 1; i >= 0; i = i - 1) {';
megaProgramCode = megaProgramCode + 'reversedString = reversedString + currentString[i];';
megaProgramCode = megaProgramCode + '}';
megaProgramCode = megaProgramCode + 'var tempArray = [];';
megaProgramCode = megaProgramCode + 'for (var i = 0; i < depth; i = i + 1) {';
megaProgramCode = megaProgramCode + 'push(tempArray, reversedString + "_" + toString(i));';
megaProgramCode = megaProgramCode + '}';
megaProgramCode = megaProgramCode + 'var tempDict = {};';
megaProgramCode = megaProgramCode + 'tempDict["depth"] = depth;';
megaProgramCode = megaProgramCode + 'tempDict["value"] = n;';
megaProgramCode = megaProgramCode + 'tempDict["string"] = currentString;';
megaProgramCode = megaProgramCode + 'tempDict["reversed"] = reversedString;';
megaProgramCode = megaProgramCode + 'tempDict["array"] = tempArray;';
megaProgramCode = megaProgramCode + 'push(accumulator, tempDict);';
megaProgramCode = megaProgramCode + 'return megaRecursiveTorture(n * 2 + depth, depth + 1, accumulator);';
megaProgramCode = megaProgramCode + '}';
megaProgramCode = megaProgramCode + 'var recursiveResult = megaRecursiveTorture(1, 0, []);';
// Add mega array operations
megaProgramCode = megaProgramCode + 'var megaArray2 = [];';
megaProgramCode = megaProgramCode + 'var megaArray3 = [];';
megaProgramCode = megaProgramCode + 'for (var i = 0; i < 1000; i = i + 1) {';
megaProgramCode = megaProgramCode + 'var complexValue = {};';
megaProgramCode = megaProgramCode + 'complexValue["index"] = i;';
megaProgramCode = megaProgramCode + 'complexValue["square"] = i * i;';
megaProgramCode = megaProgramCode + 'complexValue["cube"] = i * i * i;';
megaProgramCode = megaProgramCode + 'complexValue["string"] = "value_" + toString(i);';
megaProgramCode = megaProgramCode + 'complexValue["array"] = [i, i + 1, i + 2, i + 3, i + 4];';
megaProgramCode = megaProgramCode + 'complexValue["dict"] = {"nested": i, "deep": i * 2};';
megaProgramCode = megaProgramCode + 'push(megaArray2, complexValue);';
megaProgramCode = megaProgramCode + 'if (i % 2 == 0) { push(megaArray3, i * 2); } else { push(megaArray3, i * 3); }';
megaProgramCode = megaProgramCode + '}';
// Add dictionary madness
megaProgramCode = megaProgramCode + 'var megaDictionary = {};';
megaProgramCode = megaProgramCode + 'for (var level1 = 0; level1 < 5; level1 = level1 + 1) {';
megaProgramCode = megaProgramCode + 'var level1Key = "level1_" + toString(level1);';
megaProgramCode = megaProgramCode + 'megaDictionary[level1Key] = {};';
megaProgramCode = megaProgramCode + 'for (var level2 = 0; level2 < 5; level2 = level2 + 1) {';
megaProgramCode = megaProgramCode + 'var level2Key = "level2_" + toString(level2);';
megaProgramCode = megaProgramCode + 'megaDictionary[level1Key][level2Key] = {};';
megaProgramCode = megaProgramCode + 'for (var level3 = 0; level3 < 5; level3 = level3 + 1) {';
megaProgramCode = megaProgramCode + 'var level3Key = "level3_" + toString(level3);';
megaProgramCode = megaProgramCode + 'megaDictionary[level1Key][level2Key][level3Key] = {';
megaProgramCode = megaProgramCode + '"value": level1 * 100 + level2 * 10 + level3,';
megaProgramCode = megaProgramCode + '"string": "nested_" + toString(level1) + "_" + toString(level2) + "_" + toString(level3),';
megaProgramCode = megaProgramCode + '"array": [level1, level2, level3, level1 + level2, level2 + level3],';
megaProgramCode = megaProgramCode + '"boolean": (level1 + level2 + level3) % 2 == 0';
megaProgramCode = megaProgramCode + '};';
megaProgramCode = megaProgramCode + '}';
megaProgramCode = megaProgramCode + '}';
megaProgramCode = megaProgramCode + '}';
// Add mega eval torture
megaProgramCode = megaProgramCode + 'for (var evalIndex = 0; evalIndex < 100; evalIndex = evalIndex + 1) {';
megaProgramCode = megaProgramCode + 'var evalCode = "var evalVar_" + toString(evalIndex) + " = " + toString(evalIndex) + " * " + toString(evalIndex) + " + " + toString(evalIndex) + ";";';
megaProgramCode = megaProgramCode + 'evalCode = evalCode + "var evalString_" + toString(evalIndex) + " = \\"eval_string_" + toString(evalIndex) + "\\";";';
megaProgramCode = megaProgramCode + 'evalCode = evalCode + "var evalArray_" + toString(evalIndex) + " = [" + toString(evalIndex) + ", " + toString(evalIndex + 1) + ", " + toString(evalIndex + 2) + "];";';
megaProgramCode = megaProgramCode + 'evalCode = evalCode + "var evalResult_" + toString(evalIndex) + " = evalVar_" + toString(evalIndex) + " + len(evalString_" + toString(evalIndex) + ") + len(evalArray_" + toString(evalIndex) + ");";';
megaProgramCode = megaProgramCode + 'evalCode = evalCode + "evalResult_" + toString(evalIndex);';
megaProgramCode = megaProgramCode + 'var evalResult = eval(evalCode);';
megaProgramCode = megaProgramCode + 'if (evalIndex % 10 == 0) {';
megaProgramCode = megaProgramCode + 'print("Eval torture progress: " + toString(evalIndex) + "/100");';
megaProgramCode = megaProgramCode + '}';
megaProgramCode = megaProgramCode + '}';
// Add mega loop torture
megaProgramCode = megaProgramCode + 'var loopResults = [];';
megaProgramCode = megaProgramCode + 'var loopCounter = 0;';
megaProgramCode = megaProgramCode + 'for (var i = 0; i < 100; i = i + 1) {';
megaProgramCode = megaProgramCode + 'for (var j = 0; j < 50; j = j + 1) {';
megaProgramCode = megaProgramCode + 'for (var k = 0; k < 25; k = k + 1) {';
megaProgramCode = megaProgramCode + 'var loopValue = i * j * k;';
megaProgramCode = megaProgramCode + 'var loopString = "loop_" + toString(i) + "_" + toString(j) + "_" + toString(k);';
megaProgramCode = megaProgramCode + 'var reversedString = "";';
megaProgramCode = megaProgramCode + 'for (var l = 0; l < len(loopString); l = l + 1) {';
megaProgramCode = megaProgramCode + 'reversedString = reversedString + loopString[len(loopString) - 1 - l];';
megaProgramCode = megaProgramCode + '}';
megaProgramCode = megaProgramCode + 'var loopObject = {';
megaProgramCode = megaProgramCode + '"value": loopValue,';
megaProgramCode = megaProgramCode + '"string": loopString,';
megaProgramCode = megaProgramCode + '"reversed": reversedString,';
megaProgramCode = megaProgramCode + '"sum": i + j + k';
megaProgramCode = megaProgramCode + '};';
megaProgramCode = megaProgramCode + 'push(loopResults, loopObject);';
megaProgramCode = megaProgramCode + 'loopCounter = loopCounter + 1;';
megaProgramCode = megaProgramCode + '}';
megaProgramCode = megaProgramCode + '}';
megaProgramCode = megaProgramCode + '}';
// Add final summary
megaProgramCode = megaProgramCode + 'print("🎉 MEGA REGRESSION BUSTER 9000 COMPLETE!");';
megaProgramCode = megaProgramCode + 'print("✅ All phases completed successfully!");';
megaProgramCode = megaProgramCode + 'print("✅ Every feature tested against every other feature!");';
megaProgramCode = megaProgramCode + 'print("✅ Maximum complexity achieved!");';
megaProgramCode = megaProgramCode + 'print("✅ No regressions detected!");';
megaProgramCode = megaProgramCode + 'print("📊 FINAL STATISTICS:");';
megaProgramCode = megaProgramCode + 'print(" • Variables created: 1000+");';
megaProgramCode = megaProgramCode + 'print(" • Functions generated: 50+");';
megaProgramCode = megaProgramCode + 'print(" • Arrays processed: 5000+ elements");';
megaProgramCode = megaProgramCode + 'print(" • Dictionaries created: 1000+ entries");';
megaProgramCode = megaProgramCode + 'print(" • String characters processed: 1000+");';
megaProgramCode = megaProgramCode + 'print(" • Eval statements executed: 100+");';
megaProgramCode = megaProgramCode + 'print(" • Loop iterations: 125,000+");';
megaProgramCode = megaProgramCode + 'print(" • Conditional checks: 1000+");';
megaProgramCode = megaProgramCode + 'print(" • Arithmetic operations: 10,000+");';
megaProgramCode = megaProgramCode + 'print(" • Type conversions: 500+");';
megaProgramCode = megaProgramCode + 'print("🏆 MEGA REGRESSION TEST PASSED!");';
megaProgramCode = megaProgramCode + 'print("Bob is ROCK SOLID under maximum stress!");';
megaProgramCode = megaProgramCode + 'print("All features work perfectly together!");';
megaProgramCode = megaProgramCode + 'print("Ready for production use!");';
megaProgramCode = megaProgramCode + 'print("🚀 BOB IS UNSTOPPABLE! 🚀");';
megaProgramCode = megaProgramCode + 'print("🎊 MEGA REGRESSION BUSTER 9000 COMPLETE! 🎊");';
// Write the mega program to a file
writeFile("mega_regression_dynamic.bob", megaProgramCode);
print("✅ Mega program written to file: mega_regression_dynamic.bob");
// ========================================
// PHASE 2: LOAD AND RUN THE MEGA PROGRAM
// ========================================
print("\n📂 PHASE 2: Loading and running the mega program...");
// Check if file exists
var fileExists = fileExists("mega_regression_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
// Read the file content
var loadedCode = readFile("mega_regression_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// Use eval to run the loaded code
print("\n⚡ PHASE 3: Executing mega program with eval...");
print("🚀 STARTING MEGA REGRESSION BUSTER 9000...");
var evalResult = eval(loadedCode);
print("\n✅ MEGA PROGRAM EXECUTION COMPLETE!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire mega program!");
print("✅ All features tested successfully!");
} else {
print("❌ ERROR: File not found!");
}
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification...");
// Verify the file was created and has content
var verificationFile = readFile("mega_regression_dynamic.bob");
var fileLength = len(verificationFile);
print(" Verification file length: " + toString(fileLength) + " characters");
print(" File contains mega program: " + toString(len(verificationFile) > 1000));
// Check for key elements in the file
var containsPrint = false;
var containsFunc = false;
var containsEval = false;
for (var i = 0; i < len(verificationFile); i = i + 1) {
var char = verificationFile[i];
if (char == "p" && i + 4 < len(verificationFile)) {
if (verificationFile[i + 1] == "r" && verificationFile[i + 2] == "i" && verificationFile[i + 3] == "n" && verificationFile[i + 4] == "t") {
containsPrint = true;
}
}
if (char == "f" && i + 3 < len(verificationFile)) {
if (verificationFile[i + 1] == "u" && verificationFile[i + 2] == "n" && verificationFile[i + 3] == "c") {
containsFunc = true;
}
}
if (char == "e" && i + 2 < len(verificationFile)) {
if (verificationFile[i + 1] == "v" && verificationFile[i + 2] == "a" && verificationFile[i + 3] == "l") {
containsEval = true;
}
}
}
print(" Contains print statements: " + toString(containsPrint));
print(" Contains function definitions: " + toString(containsFunc));
print(" Contains eval statements: " + toString(containsEval));
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 MEGA REGRESSION LOADER COMPLETE!");
print("✅ Successfully wrote mega program to file");
print("✅ Successfully loaded file with file I/O");
print("✅ Successfully executed with eval");
print("✅ All features working together perfectly!");
print("\n🏆 ULTIMATE TEST PASSED!");
print("Bob can write complex programs to files!");
print("Bob can read files with file I/O!");
print("Bob can execute loaded code with eval!");
print("Bob is UNSTOPPABLE!");
print("\n🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE! 🚀");
print("🎊 MEGA REGRESSION LOADER COMPLETE! 🎊");

254
mega_loader_simple.bob
View File

@ -1,254 +0,0 @@
print("=== MEGA REGRESSION LOADER SIMPLE ===");
print("Writing mega program to file, then loading and running it...");
// ========================================
// PHASE 1: WRITE MEGA PROGRAM TO FILE
// ========================================
print("\n📝 PHASE 1: Writing mega program to file...");
var megaProgramCode = "print(\"=== MEGA REGRESSION BUSTER 9000 ===\");";
megaProgramCode = megaProgramCode + "print(\"Testing EVERY feature against EVERY other feature...\");";
// Add massive variable declarations
megaProgramCode = megaProgramCode + "var megaArray = [];";
megaProgramCode = megaProgramCode + "var megaDict = {};";
megaProgramCode = megaProgramCode + "var megaString = \"MEGA_REGRESSION_TEST_STRING\";";
megaProgramCode = megaProgramCode + "var megaNumber = 999999999.999999999;";
megaProgramCode = megaProgramCode + "var megaBoolean = true;";
megaProgramCode = megaProgramCode + "var megaNone = none;";
// Add complex nested structures
megaProgramCode = megaProgramCode + "for (var i = 0; i < 100; i = i + 1) {";
megaProgramCode = megaProgramCode + "var nestedArray = [];";
megaProgramCode = megaProgramCode + "var nestedDict = {};";
megaProgramCode = megaProgramCode + "for (var j = 0; j < 10; j = j + 1) {";
megaProgramCode = megaProgramCode + "push(nestedArray, \"nested_\" + toString(i) + \"_\" + toString(j));";
megaProgramCode = megaProgramCode + "nestedDict[\"key_\" + toString(i) + \"_\" + toString(j)] = \"value_\" + toString(i) + \"_\" + toString(j);";
megaProgramCode = megaProgramCode + "}";
megaProgramCode = megaProgramCode + "push(megaArray, nestedArray);";
megaProgramCode = megaProgramCode + "megaDict[\"dict_\" + toString(i)] = nestedDict;";
megaProgramCode = megaProgramCode + "}";
// Add function generation
megaProgramCode = megaProgramCode + "for (var funcIndex = 0; funcIndex < 50; funcIndex = funcIndex + 1) {";
megaProgramCode = megaProgramCode + "var funcName = \"megaFunc_\" + toString(funcIndex);";
megaProgramCode = megaProgramCode + "var funcCode = \"func \" + funcName + \"(a, b, c, d, e) { \";";
megaProgramCode = megaProgramCode + "funcCode = funcCode + \"var result = a + b * c - d / e; \";";
megaProgramCode = megaProgramCode + "funcCode = funcCode + \"if (result > 1000) { \";";
megaProgramCode = megaProgramCode + "funcCode = funcCode + \"return result * 2; \";";
megaProgramCode = megaProgramCode + "funcCode = funcCode + \"} else { \";";
megaProgramCode = megaProgramCode + "funcCode = funcCode + \"return result / 2; \";";
megaProgramCode = megaProgramCode + \"} \";";
megaProgramCode = megaProgramCode + \"} \";";
megaProgramCode = megaProgramCode + "eval(funcCode);";
megaProgramCode = megaProgramCode + "var testResult = eval(funcName + \"(10, 20, 30, 5, 2)\");";
megaProgramCode = megaProgramCode + "print(\"Generated and tested \" + funcName + \": \" + toString(testResult));";
megaProgramCode = megaProgramCode + "}";
// Add string indexing madness
megaProgramCode = megaProgramCode + "var complexString = \"Hello, Bob Language! This is a MEGA test with numbers 12345\";";
megaProgramCode = megaProgramCode + "var stringAnalysis = {};";
megaProgramCode = megaProgramCode + "for (var i = 0; i < len(complexString); i = i + 1) {";
megaProgramCode = megaProgramCode + "var char = complexString[i];";
megaProgramCode = megaProgramCode + "var charInfo = {};";
megaProgramCode = megaProgramCode + "charInfo[\"character\"] = char;";
megaProgramCode = megaProgramCode + "charInfo[\"index\"] = i;";
megaProgramCode = megaProgramCode + "charInfo[\"ascii_approx\"] = i * 2 + 32;";
megaProgramCode = megaProgramCode + "if (char == \" \") { charInfo[\"type\"] = \"space\"; }";
megaProgramCode = megaProgramCode + "else if (char == \",\" || char == \"!\") { charInfo[\"type\"] = \"symbol\"; }";
megaProgramCode = megaProgramCode + "else if (char == \"0\" || char == \"1\" || char == \"2\" || char == \"3\" || char == \"4\" || char == \"5\" || char == \"6\" || char == \"7\" || char == \"8\" || char == \"9\") { charInfo[\"type\"] = \"digit\"; }";
megaProgramCode = megaProgramCode + "else if (char == \"H\" || char == \"B\" || char == \"L\") { charInfo[\"type\"] = \"uppercase\"; }";
megaProgramCode = megaProgramCode + "else { charInfo[\"type\"] = \"lowercase\"; }";
megaProgramCode = megaProgramCode + "stringAnalysis[\"char_\" + toString(i)] = charInfo;";
megaProgramCode = megaProgramCode + "}";
// Add recursive function torture
megaProgramCode = megaProgramCode + "func megaRecursiveTorture(n, depth, accumulator) {";
megaProgramCode = megaProgramCode + "if (depth > 50) { return accumulator; }";
megaProgramCode = megaProgramCode + "var currentString = \"depth_\" + toString(depth) + \"_value_\" + toString(n);";
megaProgramCode = megaProgramCode + "var reversedString = \"\";";
megaProgramCode = megaProgramCode + "for (var i = len(currentString) - 1; i >= 0; i = i - 1) {";
megaProgramCode = megaProgramCode + "reversedString = reversedString + currentString[i];";
megaProgramCode = megaProgramCode + "}";
megaProgramCode = megaProgramCode + "var tempArray = [];";
megaProgramCode = megaProgramCode + "for (var i = 0; i < depth; i = i + 1) {";
megaProgramCode = megaProgramCode + "push(tempArray, reversedString + \"_\" + toString(i));";
megaProgramCode = megaProgramCode + "}";
megaProgramCode = megaProgramCode + "var tempDict = {};";
megaProgramCode = megaProgramCode + "tempDict[\"depth\"] = depth;";
megaProgramCode = megaProgramCode + "tempDict[\"value\"] = n;";
megaProgramCode = megaProgramCode + "tempDict[\"string\"] = currentString;";
megaProgramCode = megaProgramCode + "tempDict[\"reversed\"] = reversedString;";
megaProgramCode = megaProgramCode + "tempDict[\"array\"] = tempArray;";
megaProgramCode = megaProgramCode + "push(accumulator, tempDict);";
megaProgramCode = megaProgramCode + "return megaRecursiveTorture(n * 2 + depth, depth + 1, accumulator);";
megaProgramCode = megaProgramCode + "}";
megaProgramCode = megaProgramCode + "var recursiveResult = megaRecursiveTorture(1, 0, []);";
// Add mega array operations
megaProgramCode = megaProgramCode + "var megaArray2 = [];";
megaProgramCode = megaProgramCode + "var megaArray3 = [];";
megaProgramCode = megaProgramCode + "for (var i = 0; i < 1000; i = i + 1) {";
megaProgramCode = megaProgramCode + "var complexValue = {};";
megaProgramCode = megaProgramCode + "complexValue[\"index\"] = i;";
megaProgramCode = megaProgramCode + "complexValue[\"square\"] = i * i;";
megaProgramCode = megaProgramCode + "complexValue[\"cube\"] = i * i * i;";
megaProgramCode = megaProgramCode + "complexValue[\"string\"] = \"value_\" + toString(i);";
megaProgramCode = megaProgramCode + "complexValue[\"array\"] = [i, i + 1, i + 2, i + 3, i + 4];";
megaProgramCode = megaProgramCode + "complexValue[\"dict\"] = {\"nested\": i, \"deep\": i * 2};";
megaProgramCode = megaProgramCode + "push(megaArray2, complexValue);";
megaProgramCode = megaProgramCode + "if (i % 2 == 0) { push(megaArray3, i * 2); } else { push(megaArray3, i * 3); }";
megaProgramCode = megaProgramCode + "}";
// Add mega eval torture
megaProgramCode = megaProgramCode + "for (var evalIndex = 0; evalIndex < 100; evalIndex = evalIndex + 1) {";
megaProgramCode = megaProgramCode + "var evalCode = \"var evalVar_\" + toString(evalIndex) + \" = \" + toString(evalIndex) + \" * \" + toString(evalIndex) + \" + \" + toString(evalIndex) + \";\";";
megaProgramCode = megaProgramCode + "evalCode = evalCode + \"var evalString_\" + toString(evalIndex) + \" = \\\"eval_string_\" + toString(evalIndex) + \"\\\";\";";
megaProgramCode = megaProgramCode + "evalCode = evalCode + \"var evalArray_\" + toString(evalIndex) + \" = [\" + toString(evalIndex) + \", \" + toString(evalIndex + 1) + \", \" + toString(evalIndex + 2) + \"];\";";
megaProgramCode = megaProgramCode + "evalCode = evalCode + \"var evalResult_\" + toString(evalIndex) + \" = evalVar_\" + toString(evalIndex) + \" + len(evalString_\" + toString(evalIndex) + \") + len(evalArray_\" + toString(evalIndex) + \");\";";
megaProgramCode = megaProgramCode + "evalCode = evalCode + \"evalResult_\" + toString(evalIndex);";
megaProgramCode = megaProgramCode + "var evalResult = eval(evalCode);";
megaProgramCode = megaProgramCode + "if (evalIndex % 10 == 0) {";
megaProgramCode = megaProgramCode + "print(\"Eval torture progress: \" + toString(evalIndex) + \"/100\");";
megaProgramCode = megaProgramCode + "}";
megaProgramCode = megaProgramCode + "}";
// Add mega loop torture
megaProgramCode = megaProgramCode + "var loopResults = [];";
megaProgramCode = megaProgramCode + "var loopCounter = 0;";
megaProgramCode = megaProgramCode + "for (var i = 0; i < 100; i = i + 1) {";
megaProgramCode = megaProgramCode + "for (var j = 0; j < 50; j = j + 1) {";
megaProgramCode = megaProgramCode + "for (var k = 0; k < 25; k = k + 1) {";
megaProgramCode = megaProgramCode + "var loopValue = i * j * k;";
megaProgramCode = megaProgramCode + "var loopString = \"loop_\" + toString(i) + \"_\" + toString(j) + \"_\" + toString(k);";
megaProgramCode = megaProgramCode + "var reversedString = \"\";";
megaProgramCode = megaProgramCode + "for (var l = 0; l < len(loopString); l = l + 1) {";
megaProgramCode = megaProgramCode + "reversedString = reversedString + loopString[len(loopString) - 1 - l];";
megaProgramCode = megaProgramCode + "}";
megaProgramCode = megaProgramCode + "var loopObject = {";
megaProgramCode = megaProgramCode + "\"value\": loopValue,";
megaProgramCode = megaProgramCode + "\"string\": loopString,";
megaProgramCode = megaProgramCode + "\"reversed\": reversedString,";
megaProgramCode = megaProgramCode + "\"sum\": i + j + k";
megaProgramCode = megaProgramCode + "};";
megaProgramCode = megaProgramCode + "push(loopResults, loopObject);";
megaProgramCode = megaProgramCode + "loopCounter = loopCounter + 1;";
megaProgramCode = megaProgramCode + "}";
megaProgramCode = megaProgramCode + "}";
megaProgramCode = megaProgramCode + "}";
// Add final summary
megaProgramCode = megaProgramCode + "print(\"🎉 MEGA REGRESSION BUSTER 9000 COMPLETE!\");";
megaProgramCode = megaProgramCode + "print(\"✅ All phases completed successfully!\");";
megaProgramCode = megaProgramCode + "print(\"✅ Every feature tested against every other feature!\");";
megaProgramCode = megaProgramCode + "print(\"✅ Maximum complexity achieved!\");";
megaProgramCode = megaProgramCode + "print(\"✅ No regressions detected!\");";
megaProgramCode = megaProgramCode + "print(\"📊 FINAL STATISTICS:\");";
megaProgramCode = megaProgramCode + "print(\" • Variables created: 1000+\");";
megaProgramCode = megaProgramCode + "print(\" • Functions generated: 50+\");";
megaProgramCode = megaProgramCode + "print(\" • Arrays processed: 5000+ elements\");";
megaProgramCode = megaProgramCode + "print(\" • Dictionaries created: 1000+ entries\");";
megaProgramCode = megaProgramCode + "print(\" • String characters processed: 1000+\");";
megaProgramCode = megaProgramCode + "print(\" • Eval statements executed: 100+\");";
megaProgramCode = megaProgramCode + "print(\" • Loop iterations: 125,000+\");";
megaProgramCode = megaProgramCode + "print(\" • Conditional checks: 1000+\");";
megaProgramCode = megaProgramCode + "print(\" • Arithmetic operations: 10,000+\");";
megaProgramCode = megaProgramCode + "print(\" • Type conversions: 500+\");";
megaProgramCode = megaProgramCode + "print(\"🏆 MEGA REGRESSION TEST PASSED!\");";
megaProgramCode = megaProgramCode + "print(\"Bob is ROCK SOLID under maximum stress!\");";
megaProgramCode = megaProgramCode + "print(\"All features work perfectly together!\");";
megaProgramCode = megaProgramCode + "print(\"Ready for production use!\");";
megaProgramCode = megaProgramCode + "print(\"🚀 BOB IS UNSTOPPABLE! 🚀\");";
megaProgramCode = megaProgramCode + "print(\"🎊 MEGA REGRESSION BUSTER 9000 COMPLETE! 🎊\");";
// Write the mega program to a file
writeFile("mega_regression_dynamic.bob", megaProgramCode);
print("✅ Mega program written to file: mega_regression_dynamic.bob");
// ========================================
// PHASE 2: LOAD AND RUN THE MEGA PROGRAM
// ========================================
print("\n📂 PHASE 2: Loading and running the mega program...");
// Check if file exists
var fileExists = fileExists("mega_regression_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
// Read the file content
var loadedCode = readFile("mega_regression_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// Use eval to run the loaded code
print("\n⚡ PHASE 3: Executing mega program with eval...");
print("🚀 STARTING MEGA REGRESSION BUSTER 9000...");
var evalResult = eval(loadedCode);
print("\n✅ MEGA PROGRAM EXECUTION COMPLETE!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire mega program!");
print("✅ All features tested successfully!");
} else {
print("❌ ERROR: File not found!");
}
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification...");
// Verify the file was created and has content
var verificationFile = readFile("mega_regression_dynamic.bob");
var fileLength = len(verificationFile);
print(" Verification file length: " + toString(fileLength) + " characters");
print(" File contains mega program: " + toString(len(verificationFile) > 1000));
// Check for key elements in the file
var containsPrint = false;
var containsFunc = false;
var containsEval = false;
for (var i = 0; i < len(verificationFile); i = i + 1) {
var char = verificationFile[i];
if (char == "p" && i + 4 < len(verificationFile)) {
if (verificationFile[i + 1] == "r" && verificationFile[i + 2] == "i" && verificationFile[i + 3] == "n" && verificationFile[i + 4] == "t") {
containsPrint = true;
}
}
if (char == "f" && i + 3 < len(verificationFile)) {
if (verificationFile[i + 1] == "u" && verificationFile[i + 2] == "n" && verificationFile[i + 3] == "c") {
containsFunc = true;
}
}
if (char == "e" && i + 2 < len(verificationFile)) {
if (verificationFile[i + 1] == "v" && verificationFile[i + 2] == "a" && verificationFile[i + 3] == "l") {
containsEval = true;
}
}
}
print(" Contains print statements: " + toString(containsPrint));
print(" Contains function definitions: " + toString(containsFunc));
print(" Contains eval statements: " + toString(containsEval));
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 MEGA REGRESSION LOADER COMPLETE!");
print("✅ Successfully wrote mega program to file");
print("✅ Successfully loaded file with file I/O");
print("✅ Successfully executed with eval");
print("✅ All features working together perfectly!");
print("\n🏆 ULTIMATE TEST PASSED!");
print("Bob can write complex programs to files!");
print("Bob can read files with file I/O!");
print("Bob can execute loaded code with eval!");
print("Bob is UNSTOPPABLE!");
print("\n🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE! 🚀");
print("🎊 MEGA REGRESSION LOADER COMPLETE! 🎊");

576
mega_regression_test.bob
View File

@ -1,576 +0,0 @@
print("=== MEGA REGRESSION BUSTER 9000 ===");
print("Testing EVERY feature against EVERY other feature...");
// ========================================
// PHASE 1: MEGA VARIABLE DECLARATION STORM
// ========================================
print("\n🌪️ PHASE 1: MEGA VARIABLE DECLARATION STORM");
var megaArray = [];
var megaDict = {};
var megaString = "MEGA_REGRESSION_TEST_STRING_WITH_SPECIAL_CHARS_!@#$%^&*()_+-=[]{}|;':\",./<>?";
var megaNumber = 999999999.999999999;
var megaBoolean = true;
var megaNone = none;
// Create nested structures of maximum complexity
for (var i = 0; i < 100; i = i + 1) {
var nestedArray = [];
var nestedDict = {};
for (var j = 0; j < 10; j = j + 1) {
push(nestedArray, "nested_" + toString(i) + "_" + toString(j));
nestedDict["key_" + toString(i) + "_" + toString(j)] = "value_" + toString(i) + "_" + toString(j);
}
push(megaArray, nestedArray);
megaDict["dict_" + toString(i)] = nestedDict;
}
print("✅ MEGA VARIABLE STORM COMPLETE");
// ========================================
// PHASE 2: INSANE FUNCTION GENERATION
// ========================================
print("\n🧠 PHASE 2: INSANE FUNCTION GENERATION");
// Generate 50 functions with increasing complexity
for (var funcIndex = 0; funcIndex < 50; funcIndex = funcIndex + 1) {
var funcName = "megaFunc_" + toString(funcIndex);
var funcCode = "func " + funcName + "(a, b, c, d, e) { ";
funcCode = funcCode + "var result = a + b * c - d / e; ";
funcCode = funcCode + "if (result > 1000) { ";
funcCode = funcCode + "return result * 2; ";
funcCode = funcCode + "} else { ";
funcCode = funcCode + "return result / 2; ";
funcCode = funcCode + "} ";
funcCode = funcCode + "}";
// Use eval to create the function
eval(funcCode);
// Test the function immediately
var testResult = eval(funcName + "(10, 20, 30, 5, 2)");
print(" Generated and tested " + funcName + ": " + toString(testResult));
}
print("✅ INSANE FUNCTION GENERATION COMPLETE");
// ========================================
// PHASE 3: STRING INDEXING MADNESS
// ========================================
print("\n🔤 PHASE 3: STRING INDEXING MADNESS");
var complexString = "Hello, Bob Language! This is a MEGA test with numbers 12345 and symbols !@#$%^&*()";
var stringAnalysis = {};
// Analyze every character in the string
for (var i = 0; i < len(complexString); i = i + 1) {
var char = complexString[i];
var charInfo = {};
// Create character statistics
charInfo["character"] = char;
charInfo["index"] = i;
charInfo["ascii_approx"] = i * 2 + 32; // Fake ASCII calculation
// Determine character type
if (char == " ") {
charInfo["type"] = "space";
} else if (char == "," || char == "!" || char == "@" || char == "#" || char == "$" || char == "%" || char == "^" || char == "&" || char == "*" || char == "(" || char == ")") {
charInfo["type"] = "symbol";
} else if (char == "0" || char == "1" || char == "2" || char == "3" || char == "4" || char == "5" || char == "6" || char == "7" || char == "8" || char == "9") {
charInfo["type"] = "digit";
} else if (char == "H" || char == "B" || char == "L" || char == "M" || char == "E" || char == "G" || char == "A" || char == "T") {
charInfo["type"] = "uppercase";
} else {
charInfo["type"] = "lowercase";
}
stringAnalysis["char_" + toString(i)] = charInfo;
}
print("✅ STRING INDEXING MADNESS COMPLETE");
// ========================================
// PHASE 4: RECURSIVE FUNCTION TORTURE
// ========================================
print("\n🔄 PHASE 4: RECURSIVE FUNCTION TORTURE");
// Create a deeply recursive function that uses all features
func megaRecursiveTorture(n, depth, accumulator) {
if (depth > 50) {
return accumulator;
}
// String manipulation
var currentString = "depth_" + toString(depth) + "_value_" + toString(n);
var reversedString = "";
for (var i = len(currentString) - 1; i >= 0; i = i - 1) {
reversedString = reversedString + currentString[i];
}
// Array manipulation
var tempArray = [];
for (var i = 0; i < depth; i = i + 1) {
push(tempArray, reversedString + "_" + toString(i));
}
// Dictionary manipulation
var tempDict = {};
tempDict["depth"] = depth;
tempDict["value"] = n;
tempDict["string"] = currentString;
tempDict["reversed"] = reversedString;
tempDict["array"] = tempArray;
// Add to accumulator
push(accumulator, tempDict);
// Recursive call with complex calculations
return megaRecursiveTorture(n * 2 + depth, depth + 1, accumulator);
}
var recursiveResult = megaRecursiveTorture(1, 0, []);
print("✅ RECURSIVE FUNCTION TORTURE COMPLETE - Generated " + toString(len(recursiveResult)) + " entries");
// ========================================
// PHASE 5: MEGA ARRAY OPERATIONS
// ========================================
print("\n📊 PHASE 5: MEGA ARRAY OPERATIONS");
var megaArray2 = [];
var megaArray3 = [];
// Create massive arrays with complex operations
for (var i = 0; i < 1000; i = i + 1) {
var complexValue = {};
complexValue["index"] = i;
complexValue["square"] = i * i;
complexValue["cube"] = i * i * i;
complexValue["string"] = "value_" + toString(i);
complexValue["array"] = [i, i + 1, i + 2, i + 3, i + 4];
complexValue["dict"] = {"nested": i, "deep": i * 2};
push(megaArray2, complexValue);
// Create another array with different pattern
if (i % 2 == 0) {
push(megaArray3, i * 2);
} else {
push(megaArray3, i * 3);
}
}
// Perform complex array operations
var arraySum = 0;
var arrayProduct = 1;
for (var i = 0; i < len(megaArray3); i = i + 1) {
arraySum = arraySum + megaArray3[i];
arrayProduct = arrayProduct * megaArray3[i];
if (arrayProduct > 1000000) {
arrayProduct = arrayProduct / 1000; // Prevent overflow
}
}
print("✅ MEGA ARRAY OPERATIONS COMPLETE - Sum: " + toString(arraySum) + ", Product: " + toString(arrayProduct));
// ========================================
// PHASE 6: DICTIONARY MADNESS
// ========================================
print("\n📚 PHASE 6: DICTIONARY MADNESS");
var megaDictionary = {};
var nestedLevels = 10;
// Create deeply nested dictionaries
for (var level1 = 0; level1 < 5; level1 = level1 + 1) {
var level1Key = "level1_" + toString(level1);
megaDictionary[level1Key] = {};
for (var level2 = 0; level2 < 5; level2 = level2 + 1) {
var level2Key = "level2_" + toString(level2);
megaDictionary[level1Key][level2Key] = {};
for (var level3 = 0; level3 < 5; level3 = level3 + 1) {
var level3Key = "level3_" + toString(level3);
megaDictionary[level1Key][level2Key][level3Key] = {
"value": level1 * 100 + level2 * 10 + level3,
"string": "nested_" + toString(level1) + "_" + toString(level2) + "_" + toString(level3),
"array": [level1, level2, level3, level1 + level2, level2 + level3],
"boolean": (level1 + level2 + level3) % 2 == 0
};
}
}
}
print("✅ DICTIONARY MADNESS COMPLETE");
// ========================================
// PHASE 7: STRING PROCESSING TORTURE
// ========================================
print("\n🔤 PHASE 7: STRING PROCESSING TORTURE");
var megaText = "This is a MEGA string processing test with LOTS of characters and special symbols !@#$%^&*()_+-=[]{}|;':\",./<>? and numbers 1234567890 and mixed case letters ABCDEFGHIJKLMNOPQRSTUVWXYZ and abcdefghijklmnopqrstuvwxyz";
var processedStrings = [];
var stringStats = {};
// Process the string in multiple ways
for (var i = 0; i < len(megaText); i = i + 1) {
var char = megaText[i];
var charInfo = {};
// Character analysis
charInfo["original"] = char;
charInfo["index"] = i;
// Create variations
var variations = [];
for (var j = 0; j < 5; j = j + 1) {
variations[j] = char + "_" + toString(j) + "_" + toString(i);
}
charInfo["variations"] = variations;
// Character statistics
if (char == " ") {
charInfo["type"] = "space";
charInfo["count"] = 1;
} else if (char == "A" || char == "B" || char == "C" || char == "D" || char == "E" || char == "F" || char == "G" || char == "H" || char == "I" || char == "J" || char == "K" || char == "L" || char == "M" || char == "N" || char == "O" || char == "P" || char == "Q" || char == "R" || char == "S" || char == "T" || char == "U" || char == "V" || char == "W" || char == "X" || char == "Y" || char == "Z") {
charInfo["type"] = "uppercase";
charInfo["count"] = 2;
} else if (char == "a" || char == "b" || char == "c" || char == "d" || char == "e" || char == "f" || char == "g" || char == "h" || char == "i" || char == "j" || char == "k" || char == "l" || char == "m" || char == "n" || char == "o" || char == "p" || char == "q" || char == "r" || char == "s" || char == "t" || char == "u" || char == "v" || char == "w" || char == "x" || char == "y" || char == "z") {
charInfo["type"] = "lowercase";
charInfo["count"] = 3;
} else if (char == "0" || char == "1" || char == "2" || char == "3" || char == "4" || char == "5" || char == "6" || char == "7" || char == "8" || char == "9") {
charInfo["type"] = "digit";
charInfo["count"] = 4;
} else {
charInfo["type"] = "symbol";
charInfo["count"] = 5;
}
push(processedStrings, charInfo);
}
print("✅ STRING PROCESSING TORTURE COMPLETE - Processed " + toString(len(processedStrings)) + " characters");
// ========================================
// PHASE 8: MEGA EVAL TORTURE
// ========================================
print("\n⚡ PHASE 8: MEGA EVAL TORTURE");
// Generate and execute complex eval statements
for (var evalIndex = 0; evalIndex < 100; evalIndex = evalIndex + 1) {
var evalCode = "var evalVar_" + toString(evalIndex) + " = " + toString(evalIndex) + " * " + toString(evalIndex) + " + " + toString(evalIndex) + ";";
evalCode = evalCode + "var evalString_" + toString(evalIndex) + " = \"eval_string_" + toString(evalIndex) + "\";";
evalCode = evalCode + "var evalArray_" + toString(evalIndex) + " = [" + toString(evalIndex) + ", " + toString(evalIndex + 1) + ", " + toString(evalIndex + 2) + "];";
evalCode = evalCode + "var evalResult_" + toString(evalIndex) + " = evalVar_" + toString(evalIndex) + " + len(evalString_" + toString(evalIndex) + ") + len(evalArray_" + toString(evalIndex) + ");";
evalCode = evalCode + "evalResult_" + toString(evalIndex);
var evalResult = eval(evalCode);
if (evalIndex % 10 == 0) {
print(" Eval torture progress: " + toString(evalIndex) + "/100");
}
}
print("✅ MEGA EVAL TORTURE COMPLETE");
// ========================================
// PHASE 9: MEGA FUNCTION COMPOSITION
// ========================================
print("\n🎭 PHASE 9: MEGA FUNCTION COMPOSITION");
// Create functions that return functions that return functions...
func createFunctionFactory(level) {
if (level <= 0) {
return func(x) { return x * 2; };
} else {
var innerFactory = createFunctionFactory(level - 1);
return func(x) {
var innerFunc = innerFactory(x);
return innerFunc + level;
};
}
}
var megaFunction = createFunctionFactory(10);
var functionResult = megaFunction(5);
print("✅ MEGA FUNCTION COMPOSITION COMPLETE - Result: " + toString(functionResult));
// ========================================
// PHASE 10: MEGA MEMORY TORTURE
// ========================================
print("\n🧠 PHASE 10: MEGA MEMORY TORTURE");
var memoryTortureArray = [];
var memoryTortureDict = {};
// Create massive data structures
for (var i = 0; i < 5000; i = i + 1) {
var complexObject = {};
complexObject["id"] = i;
complexObject["data"] = "memory_torture_data_" + toString(i);
complexObject["nested"] = {
"level1": i * 2,
"level2": i * 3,
"level3": i * 4,
"array": [i, i + 1, i + 2, i + 3, i + 4, i + 5]
};
push(memoryTortureArray, complexObject);
memoryTortureDict["key_" + toString(i)] = complexObject;
}
// Perform operations on the massive data
var totalSum = 0;
for (var i = 0; i < len(memoryTortureArray); i = i + 1) {
totalSum = totalSum + memoryTortureArray[i]["id"];
}
print("✅ MEGA MEMORY TORTURE COMPLETE - Total sum: " + toString(totalSum));
// ========================================
// PHASE 11: MEGA LOOP TORTURE
// ========================================
print("\n🔄 PHASE 11: MEGA LOOP TORTURE");
var loopResults = [];
var loopCounter = 0;
// Nested loops with complex operations
for (var i = 0; i < 100; i = i + 1) {
for (var j = 0; j < 50; j = j + 1) {
for (var k = 0; k < 25; k = k + 1) {
var loopValue = i * j * k;
var loopString = "loop_" + toString(i) + "_" + toString(j) + "_" + toString(k);
// String processing in loops
var reversedString = "";
for (var l = 0; l < len(loopString); l = l + 1) {
reversedString = reversedString + loopString[len(loopString) - 1 - l];
}
var loopObject = {
"value": loopValue,
"string": loopString,
"reversed": reversedString,
"sum": i + j + k
};
push(loopResults, loopObject);
loopCounter = loopCounter + 1;
}
}
}
print("✅ MEGA LOOP TORTURE COMPLETE - Generated " + toString(loopCounter) + " loop results");
// ========================================
// PHASE 12: MEGA CONDITIONAL TORTURE
// ========================================
print("\n🎯 PHASE 12: MEGA CONDITIONAL TORTURE");
var conditionalResults = [];
for (var i = 0; i < 1000; i = i + 1) {
var result = {};
// Complex conditional logic
if (i % 2 == 0 && i % 3 == 0 && i % 5 == 0) {
result["type"] = "divisible_by_30";
result["value"] = i * 10;
} else if (i % 2 == 0 && i % 3 == 0) {
result["type"] = "divisible_by_6";
result["value"] = i * 5;
} else if (i % 2 == 0) {
result["type"] = "even";
result["value"] = i * 2;
} else if (i % 3 == 0) {
result["type"] = "divisible_by_3";
result["value"] = i * 3;
} else if (i % 5 == 0) {
result["type"] = "divisible_by_5";
result["value"] = i * 5;
} else {
result["type"] = "prime_candidate";
result["value"] = i;
}
// Additional string processing
result["string"] = "conditional_" + toString(i);
result["length"] = len(result["string"]);
push(conditionalResults, result);
}
print("✅ MEGA CONDITIONAL TORTURE COMPLETE");
// ========================================
// PHASE 13: MEGA ARITHMETIC TORTURE
// ========================================
print("\n🧮 PHASE 13: MEGA ARITHMETIC TORTURE");
var arithmeticResults = [];
for (var i = 0; i < 1000; i = i + 1) {
var complexCalc = {};
// Complex arithmetic operations
complexCalc["addition"] = i + i * 2 + i * 3;
complexCalc["multiplication"] = i * i * i;
complexCalc["division"] = i / (i + 1);
complexCalc["modulo"] = i % 7;
complexCalc["power"] = i * i; // Simulated power
// Bitwise operations
complexCalc["bitwise_and"] = i & 255;
complexCalc["bitwise_or"] = i | 128;
complexCalc["bitwise_xor"] = i ^ 64;
complexCalc["left_shift"] = i << 2;
complexCalc["right_shift"] = i >> 1;
// Compound operations
complexCalc["compound"] = (i + 1) * (i + 2) / (i + 3) - (i + 4) % (i + 5);
push(arithmeticResults, complexCalc);
}
print("✅ MEGA ARITHMETIC TORTURE COMPLETE");
// ========================================
// PHASE 14: MEGA TYPE CONVERSION TORTURE
// ========================================
print("\n🔄 PHASE 14: MEGA TYPE CONVERSION TORTURE");
var conversionResults = [];
for (var i = 0; i < 500; i = i + 1) {
var conversion = {};
// Number to string conversions
conversion["number"] = i;
conversion["number_string"] = toString(i);
conversion["number_string_length"] = len(toString(i));
// String to number conversions
conversion["string"] = "value_" + toString(i);
conversion["string_number"] = toNumber(toString(i));
// Boolean conversions
conversion["boolean"] = i % 2 == 0;
conversion["boolean_string"] = toString(i % 2 == 0);
// Array conversions
conversion["array"] = [i, i + 1, i + 2];
conversion["array_string"] = toString([i, i + 1, i + 2]);
// Dictionary conversions
conversion["dict"] = {"key": i, "value": i * 2};
conversion["dict_string"] = toString({"key": i, "value": i * 2});
push(conversionResults, conversion);
}
print("✅ MEGA TYPE CONVERSION TORTURE COMPLETE");
// ========================================
// PHASE 15: MEGA FINAL INTEGRATION TEST
// ========================================
print("\n🏁 PHASE 15: MEGA FINAL INTEGRATION TEST");
// Combine everything in one massive operation
var finalIntegration = {};
// String processing with all features
var finalString = "FINAL_INTEGRATION_TEST_STRING";
var processedFinalString = "";
for (var i = 0; i < len(finalString); i = i + 1) {
var char = finalString[i];
if (char == "_") {
processedFinalString = processedFinalString + " ";
} else {
processedFinalString = processedFinalString + char;
}
}
finalIntegration["original_string"] = finalString;
finalIntegration["processed_string"] = processedFinalString;
finalIntegration["string_length"] = len(finalString);
// Array operations with all features
var finalArray = [];
for (var i = 0; i < 100; i = i + 1) {
var arrayElement = {
"index": i,
"value": i * i,
"string": "element_" + toString(i),
"boolean": i % 2 == 0
};
push(finalArray, arrayElement);
}
finalIntegration["final_array"] = finalArray;
finalIntegration["array_length"] = len(finalArray);
// Dictionary operations with all features
var finalDict = {};
for (var i = 0; i < 50; i = i + 1) {
finalDict["key_" + toString(i)] = {
"nested_value": i * 3,
"nested_string": "nested_" + toString(i),
"nested_array": [i, i + 1, i + 2]
};
}
finalIntegration["final_dict"] = finalDict;
// Function operations with all features
func finalFunction(a, b, c) {
var result = a + b * c;
var resultString = toString(result);
var resultArray = [result, result * 2, result * 3];
var resultDict = {"value": result, "string": resultString, "array": resultArray};
return resultDict;
}
var functionResult = finalFunction(10, 20, 30);
finalIntegration["function_result"] = functionResult;
// Eval operations with all features
var evalCode = "var evalVar = 999; var evalString = \"EVAL_TEST\"; var evalArray = [1, 2, 3, 4, 5]; var evalResult = evalVar + len(evalString) + len(evalArray); evalResult;";
var evalResult = eval(evalCode);
finalIntegration["eval_result"] = evalResult;
print("✅ MEGA FINAL INTEGRATION TEST COMPLETE");
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 MEGA REGRESSION BUSTER 9000 COMPLETE!");
print("✅ All phases completed successfully!");
print("✅ Every feature tested against every other feature!");
print("✅ Maximum complexity achieved!");
print("✅ No regressions detected!");
print("\n📊 FINAL STATISTICS:");
print(" • Variables created: 1000+");
print(" • Functions generated: 50+");
print(" • Arrays processed: 5000+ elements");
print(" • Dictionaries created: 1000+ entries");
print(" • String characters processed: 1000+");
print(" • Eval statements executed: 100+");
print(" • Loop iterations: 125,000+");
print(" • Conditional checks: 1000+");
print(" • Arithmetic operations: 10,000+");
print(" • Type conversions: 500+");
print("\n🏆 MEGA REGRESSION TEST PASSED!");
print("Bob is ROCK SOLID under maximum stress!");
print("All features work perfectly together!");
print("Ready for production use!");
print("\n🚀 BOB IS UNSTOPPABLE! 🚀");
print("🎊 MEGA REGRESSION BUSTER 9000 COMPLETE! 🎊");

26
minimal_working.bob
View File

@ -1,26 +0,0 @@
print("=== MINIMAL WORKING TEST ===");
// Test 1: Simple eval
print("Test 1: Simple eval");
var result1 = eval("print(\"Hello from eval\");");
print("Test 1 passed");
// Test 2: Eval with variable
print("Test 2: Eval with variable");
var result2 = eval("var x = 5; print(\"x = \" + toString(x));");
print("Test 2 passed");
// Test 3: Eval with function
print("Test 3: Eval with function");
var result3 = eval("func test() { return 42; } var y = test(); print(\"y = \" + toString(y));");
print("Test 3 passed");
// Test 4: Write simple code to file and eval
print("Test 4: File I/O with eval");
var simpleCode = "print(\"Hello from file\");";
writeFile("simple.bob", simpleCode);
var loadedCode = readFile("simple.bob");
var result4 = eval(loadedCode);
print("Test 4 passed");
print("All minimal tests passed!");

5
names.txt
View File

@ -1,5 +0,0 @@
Alice
Bob
Charlie
Diana
Eve

1
original.txt
View File

@ -1 +0,0 @@
Important data

3
people.txt
View File

@ -1,3 +0,0 @@
Alice,30,Engineer
Bob,25,Designer
Charlie,35,Manager

29
proper_regression_dynamic.bob
View File

@ -1,29 +0,0 @@
print("=== PROPER REGRESSION BUSTER ===");
print("Testing ALL features with correct syntax...");
var testArray = [];
var testDict = {};
var testString = "Hello, Bob!";
var testNumber = 42;
var testBoolean = true;
for (var i = 0; i < 10; i = i + 1) {
push(testArray, i * i);
testDict["key_" + toString(i)] = i * 2;
}
print("String indexing test:");
for (var i = 0; i < len(testString); i = i + 1) {
print("Character " + toString(i) + ": " + testString[i]);
}
func testFunction(x, y) {
return x + y * 2;
}
var result = testFunction(5, 10);
print("Function result: " + toString(result));
var evalResult = eval("5 * 5 + 10");
print("Eval result: " + toString(evalResult));
print("✅ All core features working!");
print("✅ Arrays: " + toString(len(testArray)) + " elements");
print("✅ Dictionaries: " + toString(len(testDict)) + " entries");
print("✅ String indexing: " + toString(len(testString)) + " characters");
print("✅ Functions: working");
print("✅ Eval: working");
print("🎉 PROPER REGRESSION TEST PASSED!");

114
proper_regression_test.bob
View File

@ -1,114 +0,0 @@
print("=== PROPER REGRESSION TEST ===");
print("Generating correct Bob code with proper syntax...");
// ========================================
// PHASE 1: WRITE CORRECT BOB CODE TO FILE
// ========================================
print("\n📝 PHASE 1: Writing correct Bob code to file...");
// Create a properly formatted Bob program with correct syntax
var correctProgram = "print(\"=== PROPER REGRESSION BUSTER ===\");\n";
correctProgram = correctProgram + "print(\"Testing ALL features with correct syntax...\");\n";
// Add basic variable declarations with proper semicolons
correctProgram = correctProgram + "var testArray = [];\n";
correctProgram = correctProgram + "var testDict = {};\n";
correctProgram = correctProgram + "var testString = \"Hello, Bob!\";\n";
correctProgram = correctProgram + "var testNumber = 42;\n";
correctProgram = correctProgram + "var testBoolean = true;\n";
// Add array operations with proper syntax
correctProgram = correctProgram + "for (var i = 0; i < 10; i = i + 1) {\n";
correctProgram = correctProgram + " push(testArray, i * i);\n";
correctProgram = correctProgram + " testDict[\"key_\" + toString(i)] = i * 2;\n";
correctProgram = correctProgram + "}\n";
// Add string indexing with proper syntax
correctProgram = correctProgram + "print(\"String indexing test:\");\n";
correctProgram = correctProgram + "for (var i = 0; i < len(testString); i = i + 1) {\n";
correctProgram = correctProgram + " print(\"Character \" + toString(i) + \": \" + testString[i]);\n";
correctProgram = correctProgram + "}\n";
// Add function definition with proper syntax
correctProgram = correctProgram + "func testFunction(x, y) {\n";
correctProgram = correctProgram + " return x + y * 2;\n";
correctProgram = correctProgram + "}\n";
correctProgram = correctProgram + "var result = testFunction(5, 10);\n";
correctProgram = correctProgram + "print(\"Function result: \" + toString(result));\n";
// Add eval test with proper syntax
correctProgram = correctProgram + "var evalResult = eval(\"5 * 5 + 10\");\n";
correctProgram = correctProgram + "print(\"Eval result: \" + toString(evalResult));\n";
// Add final summary with proper syntax
correctProgram = correctProgram + "print(\"✅ All core features working!\");\n";
correctProgram = correctProgram + "print(\"✅ Arrays: \" + toString(len(testArray)) + \" elements\");\n";
correctProgram = correctProgram + "print(\"✅ Dictionaries: \" + toString(len(testDict)) + \" entries\");\n";
correctProgram = correctProgram + "print(\"✅ String indexing: \" + toString(len(testString)) + \" characters\");\n";
correctProgram = correctProgram + "print(\"✅ Functions: working\");\n";
correctProgram = correctProgram + "print(\"✅ Eval: working\");\n";
correctProgram = correctProgram + "print(\"🎉 PROPER REGRESSION TEST PASSED!\");\n";
// Write the correct program to a file
writeFile("proper_regression_dynamic.bob", correctProgram);
print("✅ Correct Bob code written to file: proper_regression_dynamic.bob");
// ========================================
// PHASE 2: LOAD AND RUN THE CORRECT PROGRAM
// ========================================
print("\n📂 PHASE 2: Loading and running the correct program...");
// Check if file exists
var fileExists = fileExists("proper_regression_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
// Read the file content
var loadedCode = readFile("proper_regression_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// Use eval to run the loaded code
print("\n⚡ PHASE 3: Executing correct program with eval...");
print("🚀 STARTING PROPER REGRESSION BUSTER...");
var evalResult = eval(loadedCode);
print("\n✅ PROGRAM EXECUTION COMPLETE!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire program!");
print("✅ All features tested successfully!");
} else {
print("❌ ERROR: File not found!");
}
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification...");
// Verify the file was created and has content
var verificationFile = readFile("proper_regression_dynamic.bob");
var fileLength = len(verificationFile);
print(" Verification file length: " + toString(fileLength) + " characters");
print(" File contains correct program: " + toString(len(verificationFile) > 100));
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 PROPER REGRESSION TEST COMPLETE!");
print("✅ Successfully wrote correct Bob code to file");
print("✅ Successfully loaded file with file I/O");
print("✅ Successfully executed with eval");
print("✅ All features working together perfectly!");
print("\n🏆 PROPER TEST PASSED!");
print("Bob can write correct programs to files!");
print("Bob can read files with file I/O!");
print("Bob can execute loaded code with eval!");
print("Bob is UNSTOPPABLE!");
print("\n🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE! 🚀");
print("🎊 PROPER REGRESSION TEST COMPLETE! 🎊");

1
simple.bob
View File

@ -1 +0,0 @@
print("Hello from file");

29
simple_regression_dynamic.bob
View File

@ -1,29 +0,0 @@
print("=== SIMPLE REGRESSION BUSTER ===");
print("Testing core features...");
var testArray = [];
var testDict = {};
var testString = "Hello, Bob!";
var testNumber = 42;
var testBoolean = true;
for (var i = 0; i < 10; i = i + 1) {
push(testArray, i * i);
testDict["key_" + toString(i)] = i * 2;
}
print("String indexing test:");
for (var i = 0; i < len(testString); i = i + 1) {
print("Character " + toString(i) + ": " + testString[i]);
}
func testFunction(x, y) {
return x + y * 2;
}
var result = testFunction(5, 10);
print("Function result: " + toString(result));
var evalResult = eval("5 * 5 + 10");
print("Eval result: " + toString(evalResult));
print("✅ All core features working!");
print("✅ Arrays: " + toString(len(testArray)) + " elements");
print("✅ Dictionaries: " + toString(len(testDict)) + " entries");
print("✅ String indexing: " + toString(len(testString)) + " characters");
print("✅ Functions: working");
print("✅ Eval: working");
print("🎉 SIMPLE REGRESSION TEST PASSED!");

274
string_indexing_demo.bob
View File

@ -1,274 +0,0 @@
print("=== STRING INDEXING DEMONSTRATION ===");
print("Showing Bob's new text processing capabilities...");
// ========================================
// DEMO 1: BASIC STRING OPERATIONS
// ========================================
print("\n🔤 DEMO 1: Basic String Operations");
var message = "Hello, Bob Language!";
print(" Original: " + message);
print(" Length: " + toString(len(message)));
// Extract characters
var first = message[0];
var last = message[len(message) - 1];
var middle = message[7];
print(" First character: " + first);
print(" Last character: " + last);
print(" Character at index 7: " + middle);
// ========================================
// DEMO 2: STRING ANALYSIS
// ========================================
print("\n📊 DEMO 2: String Analysis");
var text = "The quick brown fox jumps over the lazy dog";
print(" Text: " + text);
// Count vowels
var vowels = 0;
for (var i = 0; i < len(text); i = i + 1) {
var char = text[i];
if (char == "a" || char == "e" || char == "i" || char == "o" || char == "u") {
vowels = vowels + 1;
}
}
print(" Vowel count: " + toString(vowels));
// Count spaces
var spaces = 0;
for (var i = 0; i < len(text); i = i + 1) {
if (text[i] == " ") {
spaces = spaces + 1;
}
}
print(" Word count: " + toString(spaces + 1));
// ========================================
// DEMO 3: TEXT TRANSFORMATION
// ========================================
print("\n🔄 DEMO 3: Text Transformation");
var original = "hello world";
print(" Original: " + original);
// Convert to uppercase (simplified)
var uppercase = "";
for (var i = 0; i < len(original); i = i + 1) {
var char = original[i];
if (char == "h") {
uppercase = uppercase + "H";
} else if (char == "w") {
uppercase = uppercase + "W";
} else {
uppercase = uppercase + char;
}
}
print(" Uppercase: " + uppercase);
// Replace spaces with underscores
var underscored = "";
for (var i = 0; i < len(original); i = i + 1) {
var char = original[i];
if (char == " ") {
underscored = underscored + "_";
} else {
underscored = underscored + char;
}
}
print(" Underscored: " + underscored);
// ========================================
// DEMO 4: STRING SEARCH AND REPLACE
// ========================================
print("\n🔍 DEMO 4: String Search and Replace");
var content = "Hello, Bob! How are you, Bob? Nice to meet you, Bob!";
var searchTerm = "Bob";
var replacement = "Alice";
var result = "";
print(" Original: " + content);
print(" Search for: " + searchTerm);
print(" Replace with: " + replacement);
var i = 0;
while (i < len(content)) {
var match = true;
if (i + len(searchTerm) <= len(content)) {
for (var j = 0; j < len(searchTerm); j = j + 1) {
if (content[i + j] != searchTerm[j]) {
match = false;
break;
}
}
} else {
match = false;
}
if (match) {
result = result + replacement;
i = i + len(searchTerm);
} else {
result = result + content[i];
i = i + 1;
}
}
print(" Result: " + result);
// ========================================
// DEMO 5: DATA PARSING
// ========================================
print("\n📝 DEMO 5: Data Parsing");
var csvData = "Alice,30,Engineer,San Francisco";
print(" CSV data: " + csvData);
// Parse CSV
var fields = [];
var currentField = "";
for (var i = 0; i < len(csvData); i = i + 1) {
var char = csvData[i];
if (char == ",") {
push(fields, currentField);
currentField = "";
} else {
currentField = currentField + char;
}
}
push(fields, currentField);
print(" Parsed fields:");
print(" Name: " + fields[0]);
print(" Age: " + fields[1]);
print(" Job: " + fields[2]);
print(" City: " + fields[3]);
// ========================================
// DEMO 6: STRING VALIDATION
// ========================================
print("\n✅ DEMO 6: String Validation");
var email = "user@example.com";
print(" Email: " + email);
// Validate email format
var hasAt = false;
var hasDot = false;
var atPosition = -1;
// Find @ symbol
for (var i = 0; i < len(email); i = i + 1) {
if (email[i] == "@") {
hasAt = true;
atPosition = i;
break;
}
}
// Check for . after @
if (hasAt) {
for (var i = atPosition + 1; i < len(email); i = i + 1) {
if (email[i] == ".") {
hasDot = true;
break;
}
}
}
var isValid = hasAt && hasDot;
print(" Has @ symbol: " + toString(hasAt));
print(" Has . after @: " + toString(hasDot));
print(" Is valid email: " + toString(isValid));
// ========================================
// DEMO 7: STRING REVERSE ENGINEERING
// ========================================
print("\n🔄 DEMO 7: String Reverse Engineering");
var palindrome = "racecar";
print(" String: " + palindrome);
// Check if palindrome
var isPalindrome = true;
for (var i = 0; i < len(palindrome) / 2; i = i + 1) {
if (palindrome[i] != palindrome[len(palindrome) - 1 - i]) {
isPalindrome = false;
break;
}
}
print(" Is palindrome: " + toString(isPalindrome));
// Reverse string
var reversed = "";
for (var i = len(palindrome) - 1; i >= 0; i = i - 1) {
reversed = reversed + palindrome[i];
}
print(" Reversed: " + reversed);
// ========================================
// DEMO 8: ADVANCED TEXT PROCESSING
// ========================================
print("\n🚀 DEMO 8: Advanced Text Processing");
var logLine = "2024-01-15 14:30:25 [INFO] User login successful";
print(" Log line: " + logLine);
// Extract timestamp
var timestamp = "";
for (var i = 0; i < 19; i = i + 1) {
timestamp = timestamp + logLine[i];
}
// Extract log level
var logLevel = "";
var levelStart = 21;
for (var i = levelStart; i < levelStart + 4; i = i + 1) {
logLevel = logLevel + logLine[i];
}
// Extract message
var message = "";
var messageStart = 27;
for (var i = messageStart; i < len(logLine); i = i + 1) {
message = message + logLine[i];
}
print(" Timestamp: " + timestamp);
print(" Log level: " + logLevel);
print(" Message: " + message);
// ========================================
// SUMMARY
// ========================================
print("\n🎉 STRING INDEXING CAPABILITIES SUMMARY ===");
print("✅ Character-by-character access");
print("✅ String length and bounds checking");
print("✅ Text analysis and counting");
print("✅ String transformation and manipulation");
print("✅ Search and replace operations");
print("✅ Data parsing (CSV, logs, etc.)");
print("✅ Input validation");
print("✅ Palindrome detection");
print("✅ Advanced text processing");
print("\n🏆 BOB NOW HAS WORLD-CLASS TEXT PROCESSING! 🏆");
print("String indexing makes Bob incredibly powerful for:");
print(" • Data processing and analysis");
print(" • Text manipulation and transformation");
print(" • Input validation and parsing");
print(" • Log file processing");
print(" • Configuration file handling");
print(" • Report generation");
print(" • String algorithms and utilities");
print("\n🚀 BOB IS READY FOR REAL-WORLD TEXT TASKS! 🚀");
print("The language has evolved from basic scripting to");
print("a powerful tool for text processing and data analysis!");
print("\n🎊 DEMONSTRATION COMPLETE! 🎊");
print("String indexing is production-ready and bulletproof!");

84
string_indexing_errors_test.bob
View File

@ -1,84 +0,0 @@
print("=== STRING INDEXING ERROR HANDLING TEST ===");
print("Testing error handling and bounds checking...");
// ========================================
// TEST 1: OUT OF BOUNDS INDEXING
// ========================================
print("\n🚫 TEST 1: Out of Bounds Indexing");
var str = "Hello";
print(" String: " + str + " (length: " + toString(len(str)) + ")");
// Test negative index
print(" Testing negative index...");
var negativeIndex = -1;
// This should cause an error
var result = str[negativeIndex];
print("✅ Negative index handling: PASS");
// ========================================
// TEST 2: INDEX TOO LARGE
// ========================================
print("\n📏 TEST 2: Index Too Large");
var shortStr = "Hi";
print(" String: " + shortStr + " (length: " + toString(len(shortStr)) + ")");
// Test index beyond string length
print(" Testing index beyond length...");
var largeIndex = 10;
// This should cause an error
var result2 = shortStr[largeIndex];
print("✅ Large index handling: PASS");
// ========================================
// TEST 3: EMPTY STRING INDEXING
// ========================================
print("\n🈳 TEST 3: Empty String Indexing");
var empty = "";
print(" Empty string length: " + toString(len(empty)));
// Test indexing empty string
print(" Testing empty string indexing...");
// This should cause an error
var result3 = empty[0];
print("✅ Empty string indexing handling: PASS");
// ========================================
// TEST 4: INVALID INDEX TYPE
// ========================================
print("\n🔢 TEST 4: Invalid Index Type");
var testStr = "Hello";
print(" String: " + testStr);
// Test string index instead of number
print(" Testing string index...");
var stringIndex = "0";
// This should cause an error
var result4 = testStr[stringIndex];
print("✅ Invalid index type handling: PASS");
// ========================================
// TEST 5: STRING ASSIGNMENT (SHOULD FAIL)
// ========================================
print("\n✏️ TEST 5: String Assignment (Should Fail)");
var mutableStr = "Hello";
print(" String: " + mutableStr);
// Test string assignment
print(" Testing string assignment...");
// This should cause an error - strings are immutable
mutableStr[0] = "X";
print("✅ String assignment error handling: PASS");
print("\n🎉 ERROR HANDLING TESTS COMPLETE! 🎉");
print("All error conditions are properly handled!");
print("String indexing is bulletproof!");

254
string_indexing_final_test.bob
View File

@ -1,254 +0,0 @@
print("=== FINAL STRING INDEXING VERIFICATION ===");
print("Comprehensive test of all string indexing features...");
// ========================================
// TEST 1: BASIC FUNCTIONALITY
// ========================================
print("\n✅ TEST 1: Basic Functionality");
var str = "Hello, Bob!";
var first = str[0];
var last = str[len(str) - 1];
print(" String: " + str);
print(" First: " + first);
print(" Last: " + last);
assert(first == "H", "First character should be 'H'");
assert(last == "!", "Last character should be '!'");
print("✅ Basic functionality: PASS");
// ========================================
// TEST 2: BOUNDS CHECKING
// ========================================
print("\n🛡️ TEST 2: Bounds Checking");
var testStr = "Bob";
var length = len(testStr);
// Test valid bounds
var valid1 = testStr[0];
var valid2 = testStr[length - 1];
print(" String: " + testStr + " (length: " + toString(length) + ")");
print(" Valid indices work: " + valid1 + ", " + valid2);
assert(valid1 == "B", "First character should be 'B'");
assert(valid2 == "b", "Last character should be 'b'");
print("✅ Bounds checking: PASS");
// ========================================
// TEST 3: STRING MANIPULATION
// ========================================
print("\n🔧 TEST 3: String Manipulation");
var original = "hello world";
var uppercase = "";
// Convert to uppercase (simplified)
for (var i = 0; i < len(original); i = i + 1) {
var char = original[i];
if (char == "h") {
uppercase = uppercase + "H";
} else if (char == "w") {
uppercase = uppercase + "W";
} else {
uppercase = uppercase + char;
}
}
print(" Original: " + original);
print(" Modified: " + uppercase);
assert(uppercase == "Hello World", "Should be 'Hello World'");
print("✅ String manipulation: PASS");
// ========================================
// TEST 4: STRING SEARCH AND REPLACE
// ========================================
print("\n🔍 TEST 4: String Search and Replace");
var text = "Hello, Bob! How are you, Bob?";
var searchTerm = "Bob";
var replacement = "Alice";
var result = "";
var i = 0;
while (i < len(text)) {
var match = true;
if (i + len(searchTerm) <= len(text)) {
for (var j = 0; j < len(searchTerm); j = j + 1) {
if (text[i + j] != searchTerm[j]) {
match = false;
break;
}
}
} else {
match = false;
}
if (match) {
result = result + replacement;
i = i + len(searchTerm);
} else {
result = result + text[i];
i = i + 1;
}
}
print(" Original: " + text);
print(" Search: " + searchTerm);
print(" Replace: " + replacement);
print(" Result: " + result);
assert(result == "Hello, Alice! How are you, Alice?", "Should replace all occurrences");
print("✅ String search and replace: PASS");
// ========================================
// TEST 5: STRING PARSING
// ========================================
print("\n📝 TEST 5: String Parsing");
var csvLine = "Alice,30,Engineer";
var fields = [];
var currentField = "";
for (var i = 0; i < len(csvLine); i = i + 1) {
var char = csvLine[i];
if (char == ",") {
// End of field
push(fields, currentField);
currentField = "";
} else {
currentField = currentField + char;
}
}
// Add the last field
push(fields, currentField);
print(" CSV line: " + csvLine);
print(" Field 0: " + fields[0]);
print(" Field 1: " + fields[1]);
print(" Field 2: " + fields[2]);
assert(fields[0] == "Alice", "First field should be 'Alice'");
assert(fields[1] == "30", "Second field should be '30'");
assert(fields[2] == "Engineer", "Third field should be 'Engineer'");
print("✅ String parsing: PASS");
// ========================================
// TEST 6: STRING VALIDATION
// ========================================
print("\n✅ TEST 6: String Validation");
var email = "user@example.com";
var isValid = true;
// Check for @ symbol
var hasAt = false;
for (var i = 0; i < len(email); i = i + 1) {
if (email[i] == "@") {
hasAt = true;
break;
}
}
// Check for . after @
var hasDot = false;
if (hasAt) {
for (var i = 0; i < len(email); i = i + 1) {
if (email[i] == "@") {
// Look for . after @
for (var j = i + 1; j < len(email); j = j + 1) {
if (email[j] == ".") {
hasDot = true;
break;
}
}
break;
}
}
}
isValid = hasAt && hasDot;
print(" Email: " + email);
print(" Has @: " + toString(hasAt));
print(" Has . after @: " + toString(hasDot));
print(" Is valid: " + toString(isValid));
assert(isValid == true, "Email should be valid");
print("✅ String validation: PASS");
// ========================================
// TEST 7: STRING FORMATTING
// ========================================
print("\n🎨 TEST 7: String Formatting");
var name = "Bob";
var age = 25;
var profession = "Programmer";
// Build formatted string
var formatted = "Name: " + name + ", Age: " + toString(age) + ", Profession: " + profession;
print(" Formatted: " + formatted);
assert(len(formatted) > 0, "Formatted string should not be empty");
print("✅ String formatting: PASS");
// ========================================
// TEST 8: STRING REVERSE ENGINEERING
// ========================================
print("\n🔄 TEST 8: String Reverse Engineering");
var original = "Hello, World!";
var reversed = "";
var length = len(original);
for (var i = length - 1; i >= 0; i = i - 1) {
reversed = reversed + original[i];
}
print(" Original: " + original);
print(" Reversed: " + reversed);
assert(len(reversed) == len(original), "Reversed string should have same length");
assert(reversed[0] == "!", "First character of reversed should be '!'");
assert(reversed[len(reversed) - 1] == "H", "Last character of reversed should be 'H'");
print("✅ String reverse engineering: PASS");
// ========================================
// SUMMARY
// ========================================
print("\n🎉 FINAL STRING INDEXING VERIFICATION RESULTS ===");
print("✅ Basic functionality");
print("✅ Bounds checking");
print("✅ String manipulation");
print("✅ String search and replace");
print("✅ String parsing");
print("✅ String validation");
print("✅ String formatting");
print("✅ String reverse engineering");
print("\n🏆 STRING INDEXING IS ABSOLUTELY ROCK SOLID! 🏆");
print("All features work perfectly!");
print("Error handling is bulletproof!");
print("Performance is excellent!");
print("Ready for production use!");
print("\n🚀 BOB NOW HAS WORLD-CLASS STRING PROCESSING! 🚀");
print("String indexing implementation is complete and solid!");
print("Bob can now handle complex text processing tasks!");
print("The language is significantly more powerful!");
print("\n🎊 FINAL VERIFICATION COMPLETE! 🎊");
print("String indexing is production-ready and bulletproof!");

373
string_indexing_test.bob
View File

@ -1,373 +0,0 @@
print("=== STRING INDEXING TEST SUITE ===");
print("Testing string indexing functionality...");
// ========================================
// TEST 1: BASIC STRING INDEXING
// ========================================
print("\n📝 TEST 1: Basic String Indexing");
var str = "Hello, Bob!";
print(" String: " + str);
// Test basic indexing
var first = str[0];
var second = str[1];
var last = str[10];
print(" First character: " + first);
print(" Second character: " + second);
print(" Last character: " + last);
assert(first == "H", "First character should be 'H'");
assert(second == "e", "Second character should be 'e'");
assert(last == "!", "Last character should be '!'");
print("✅ Basic string indexing: PASS");
// ========================================
// TEST 2: STRING LENGTH AND BOUNDS
// ========================================
print("\n📏 TEST 2: String Length and Bounds");
var testStr = "Bob";
var length = len(testStr);
print(" String: " + testStr);
print(" Length: " + toString(length));
// Test all valid indices
var char0 = testStr[0];
var char1 = testStr[1];
var char2 = testStr[2];
print(" Characters: " + char0 + ", " + char1 + ", " + char2);
assert(length == 3, "String length should be 3");
assert(char0 == "B", "Character 0 should be 'B'");
assert(char1 == "o", "Character 1 should be 'o'");
assert(char2 == "b", "Character 2 should be 'b'");
print("✅ String length and bounds: PASS");
// ========================================
// TEST 3: EMPTY STRING HANDLING
// ========================================
print("\n🈳 TEST 3: Empty String Handling");
var empty = "";
var emptyLength = len(empty);
print(" Empty string length: " + toString(emptyLength));
assert(emptyLength == 0, "Empty string length should be 0");
print("✅ Empty string handling: PASS");
// ========================================
// TEST 4: SINGLE CHARACTER STRINGS
// ========================================
print("\n🔤 TEST 4: Single Character Strings");
var single = "X";
var singleLength = len(single);
var singleChar = single[0];
print(" Single character: " + singleChar);
print(" Length: " + toString(singleLength));
assert(singleLength == 1, "Single character string length should be 1");
assert(singleChar == "X", "Single character should be 'X'");
print("✅ Single character strings: PASS");
// ========================================
// TEST 5: SPECIAL CHARACTERS
// ========================================
print("\n🎯 TEST 5: Special Characters");
var special = "Hello\nWorld\tTest";
var newline = special[5];
var tab = special[11];
print(" String with special chars: " + special);
print(" Newline character: " + newline);
print(" Tab character: " + tab);
assert(newline == "\n", "Newline character should be preserved");
assert(tab == "\t", "Tab character should be preserved");
print("✅ Special characters: PASS");
// ========================================
// TEST 6: NUMBERS AND SYMBOLS
// ========================================
print("\n🔢 TEST 6: Numbers and Symbols");
var mixed = "Hello123!@#";
var digit = mixed[5];
var symbol = mixed[8];
print(" Mixed string: " + mixed);
print(" Digit: " + digit);
print(" Symbol: " + symbol);
assert(digit == "1", "Digit should be '1'");
assert(symbol == "!", "Symbol should be '!'");
print("✅ Numbers and symbols: PASS");
// ========================================
// TEST 7: VARIABLE STRING INDEXING
// ========================================
print("\n🔄 TEST 7: Variable String Indexing");
var message = "Programming";
var indices = [0, 1, 2, 3, 4];
for (var i = 0; i < len(indices); i = i + 1) {
var idx = indices[i];
var char = message[idx];
print(" Index " + toString(idx) + ": " + char);
}
var expected = ["P", "r", "o", "g", "r"];
for (var i = 0; i < len(indices); i = i + 1) {
var idx = indices[i];
var char = message[idx];
assert(char == expected[i], "Character at index " + toString(idx) + " should be " + expected[i]);
}
print("✅ Variable string indexing: PASS");
// ========================================
// TEST 8: STRING CONCATENATION WITH INDEXING
// ========================================
print("\n🔗 TEST 8: String Concatenation with Indexing");
var str1 = "Hello";
var str2 = "World";
var combined = str1 + " " + str2;
var firstWord = "";
for (var i = 0; i < len(str1); i = i + 1) {
firstWord = firstWord + str1[i];
}
var secondWord = "";
for (var i = 0; i < len(str2); i = i + 1) {
secondWord = secondWord + str2[i];
}
print(" Combined: " + combined);
print(" First word: " + firstWord);
print(" Second word: " + secondWord);
assert(firstWord == "Hello", "First word should be 'Hello'");
assert(secondWord == "World", "Second word should be 'World'");
print("✅ String concatenation with indexing: PASS");
// ========================================
// TEST 9: STRING REVERSAL
// ========================================
print("\n🔄 TEST 9: String Reversal");
var original = "Bob";
var reversed = "";
for (var i = len(original) - 1; i >= 0; i = i - 1) {
reversed = reversed + original[i];
}
print(" Original: " + original);
print(" Reversed: " + reversed);
assert(reversed == "boB", "Reversed string should be 'boB'");
print("✅ String reversal: PASS");
// ========================================
// TEST 10: CHARACTER COUNTING
// ========================================
print("\n📊 TEST 10: Character Counting");
var text = "hello world";
var letterCount = 0;
for (var i = 0; i < len(text); i = i + 1) {
var char = text[i];
if (char == "l") {
letterCount = letterCount + 1;
}
}
print(" Text: " + text);
print(" Number of 'l' characters: " + toString(letterCount));
assert(letterCount == 3, "Should find 3 'l' characters");
print("✅ Character counting: PASS");
// ========================================
// TEST 11: STRING COMPARISON WITH INDEXING
// ========================================
print("\n🔍 TEST 11: String Comparison with Indexing");
var strA = "apple";
var strB = "apple";
var areEqual = true;
if (len(strA) != len(strB)) {
areEqual = false;
} else {
for (var i = 0; i < len(strA); i = i + 1) {
if (strA[i] != strB[i]) {
areEqual = false;
break;
}
}
}
print(" String A: " + strA);
print(" String B: " + strB);
print(" Are equal: " + toString(areEqual));
assert(areEqual == true, "Strings should be equal");
print("✅ String comparison with indexing: PASS");
// ========================================
// TEST 12: STRING SEARCH
// ========================================
print("\n🔎 TEST 12: String Search");
var haystack = "Hello, Bob!";
var needle = "Bob";
var found = false;
var foundIndex = -1;
for (var i = 0; i <= len(haystack) - len(needle); i = i + 1) {
var match = true;
for (var j = 0; j < len(needle); j = j + 1) {
if (haystack[i + j] != needle[j]) {
match = false;
break;
}
}
if (match) {
found = true;
foundIndex = i;
break;
}
}
print(" Haystack: " + haystack);
print(" Needle: " + needle);
print(" Found: " + toString(found));
print(" Index: " + toString(foundIndex));
assert(found == true, "Should find 'Bob' in the string");
assert(foundIndex == 7, "Should find 'Bob' at index 7");
print("✅ String search: PASS");
// ========================================
// TEST 13: STRING SLICING SIMULATION
// ========================================
print("\n✂️ TEST 13: String Slicing Simulation");
var fullString = "Hello, World!";
var start = 0;
var end = 5;
var slice = "";
for (var i = start; i < end; i = i + 1) {
slice = slice + fullString[i];
}
print(" Full string: " + fullString);
print(" Slice [0:5]: " + slice);
assert(slice == "Hello", "Slice should be 'Hello'");
print("✅ String slicing simulation: PASS");
// ========================================
// TEST 14: STRING VALIDATION
// ========================================
print("\n✅ TEST 14: String Validation");
var email = "user@example.com";
var hasAt = false;
var hasDot = false;
for (var i = 0; i < len(email); i = i + 1) {
var char = email[i];
if (char == "@") {
hasAt = true;
}
if (char == ".") {
hasDot = true;
}
}
print(" Email: " + email);
print(" Has @: " + toString(hasAt));
print(" Has .: " + toString(hasDot));
assert(hasAt == true, "Email should contain @");
assert(hasDot == true, "Email should contain .");
print("✅ String validation: PASS");
// ========================================
// TEST 15: STRING TRANSFORMATION
// ========================================
print("\n🔄 TEST 15: String Transformation");
var original = "hello world";
var transformed = "";
for (var i = 0; i < len(original); i = i + 1) {
var char = original[i];
if (char == " ") {
transformed = transformed + "_";
} else {
transformed = transformed + char;
}
}
print(" Original: " + original);
print(" Transformed: " + transformed);
assert(transformed == "hello_world", "Transformed string should be 'hello_world'");
print("✅ String transformation: PASS");
// ========================================
// SUMMARY
// ========================================
print("\n🎉 STRING INDEXING TEST RESULTS ===");
print("✅ Basic string indexing");
print("✅ String length and bounds");
print("✅ Empty string handling");
print("✅ Single character strings");
print("✅ Special characters");
print("✅ Numbers and symbols");
print("✅ Variable string indexing");
print("✅ String concatenation with indexing");
print("✅ String reversal");
print("✅ Character counting");
print("✅ String comparison with indexing");
print("✅ String search");
print("✅ String slicing simulation");
print("✅ String validation");
print("✅ String transformation");
print("\n🏆 STRING INDEXING IS ROCK SOLID! 🏆");
print("All string indexing operations work perfectly!");
print("Bob can now process text with precision!");
print("Ready for advanced text processing tasks!");
print("\n🎊 STRING INDEXING TESTS COMPLETE! 🎊");
print("String indexing is bulletproof and production-ready!");

121
success_demonstration.bob
View File

@ -1,121 +0,0 @@
print("=== SUCCESS DEMONSTRATION ===");
print("Showing what we successfully accomplished...");
// ========================================
// PHASE 1: DEMONSTRATE FILE I/O SUCCESS
// ========================================
print("\n📝 PHASE 1: File I/O Success Demonstration");
// Create a simple program
var programCode = "print(\"Hello from generated program!\");\n";
programCode = programCode + "var x = 10;\n";
programCode = programCode + "var y = 20;\n";
programCode = programCode + "print(\"Sum: \" + toString(x + y));\n";
// Write to file
writeFile("success_test.bob", programCode);
print("✅ Program written to file successfully!");
// Read from file
var loadedCode = readFile("success_test.bob");
print("✅ Program read from file successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// ========================================
// PHASE 2: DEMONSTRATE ALL FEATURES WORKING
// ========================================
print("\n🎯 PHASE 2: All Features Working Demonstration");
// Test arrays
var demoArray = [];
for (var i = 0; i < 5; i = i + 1) {
push(demoArray, i * i);
}
print("✅ Array test: " + toString(len(demoArray)) + " elements");
// Test dictionaries
var demoDict = {};
demoDict["key1"] = "value1";
demoDict["key2"] = "value2";
demoDict["key3"] = "value3";
print("✅ Dictionary test: " + toString(len(demoDict)) + " entries");
// Test string indexing
var demoString = "Hello, Bob!";
var reversedString = "";
for (var i = len(demoString) - 1; i >= 0; i = i - 1) {
reversedString = reversedString + demoString[i];
}
print("✅ String indexing test: " + demoString + " -> " + reversedString);
// Test functions
func demoFunction(a, b) {
return a + b * 2;
}
var funcResult = demoFunction(3, 4);
print("✅ Function test: demoFunction(3, 4) = " + toString(funcResult));
// Test eval
var evalTest = eval("10 * 5 + 20");
print("✅ Eval test: eval(\"10 * 5 + 20\") = " + toString(evalTest));
// ========================================
// PHASE 3: DEMONSTRATE COMPLEX PROGRAM GENERATION
// ========================================
print("\n🚀 PHASE 3: Complex Program Generation");
// Generate a more complex program
var complexProgram = "print(\"=== COMPLEX GENERATED PROGRAM ===\");\n";
complexProgram = complexProgram + "var megaArray = [];\n";
complexProgram = complexProgram + "var megaDict = {};\n";
complexProgram = complexProgram + "for (var i = 0; i < 10; i = i + 1) {\n";
complexProgram = complexProgram + "push(megaArray, i * i);\n";
complexProgram = complexProgram + "megaDict[\"key_\" + toString(i)] = i * 2;\n";
complexProgram = complexProgram + "}\n";
complexProgram = complexProgram + "print(\"Generated array: \" + toString(len(megaArray)) + \" elements\");\n";
complexProgram = complexProgram + "print(\"Generated dict: \" + toString(len(megaDict)) + \" entries\");\n";
complexProgram = complexProgram + "print(\"✅ COMPLEX PROGRAM GENERATION SUCCESS!\");\n";
// Write complex program
writeFile("complex_generated.bob", complexProgram);
print("✅ Complex program written to file!");
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification");
// Check both files exist
var simpleExists = fileExists("success_test.bob");
var complexExists = fileExists("complex_generated.bob");
print(" Simple test file exists: " + toString(simpleExists));
print(" Complex test file exists: " + toString(complexExists));
// Read and verify content
var simpleContent = readFile("success_test.bob");
var complexContent = readFile("complex_generated.bob");
print(" Simple file size: " + toString(len(simpleContent)) + " characters");
print(" Complex file size: " + toString(len(complexContent)) + " characters");
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 SUCCESS DEMONSTRATION COMPLETE!");
print("✅ File I/O working perfectly!");
print("✅ Program generation working!");
print("✅ All core features working!");
print("✅ String indexing working!");
print("✅ Functions working!");
print("✅ Eval working!");
print("✅ Arrays working!");
print("✅ Dictionaries working!");
print("\n🏆 WHAT WE ACCOMPLISHED:");
print("• Successfully wrote complex programs to files");
print("• Successfully read programs from files");
print("• Generated programs with all Bob features");
print("• Demonstrated file I/O integration");
print("• Showed all features working together");
print("\n🚀 BOB IS UNSTOPPABLE!");
print("🎊 SUCCESS DEMONSTRATION COMPLETE! 🎊");

4
success_test.bob
View File

@ -1,4 +0,0 @@
print("Hello from generated program!");
var x = 10;
var y = 20;
print("Sum: " + toString(x + y));

4
test.txt
View File

@ -1,4 +0,0 @@
Hello, this is a test file!
This is line 2.
This is line 3.
End of file.

200
ultimate_regression.bob
View File

@ -1,200 +0,0 @@
print("=== ULTIMATE REGRESSION TEST ===");
print("Creating the most complex regression busting program ever...");
// ========================================
// PHASE 1: BUILD THE ULTIMATE PROGRAM
// ========================================
print("\n🚀 PHASE 1: Building the ultimate program...");
var ultimateProgram = "";
ultimateProgram = ultimateProgram + "print(\"=== ULTIMATE REGRESSION BUSTER ===\");\n";
ultimateProgram = ultimateProgram + "print(\"Testing EVERY feature with maximum complexity...\");\n";
// Test 1: Basic variables and types
ultimateProgram = ultimateProgram + "print(\"\\n📊 TEST 1: Basic Types\");\n";
ultimateProgram = ultimateProgram + "var number = 42;\n";
ultimateProgram = ultimateProgram + "var string = \"Hello, Ultimate Bob!\";\n";
ultimateProgram = ultimateProgram + "var boolean = true;\n";
ultimateProgram = ultimateProgram + "var array = [];\n";
ultimateProgram = ultimateProgram + "var dict = {};\n";
ultimateProgram = ultimateProgram + "print(\"✅ Basic types created\");\n";
// Test 2: Array operations
ultimateProgram = ultimateProgram + "print(\"\\n📊 TEST 2: Array Operations\");\n";
ultimateProgram = ultimateProgram + "for (var i = 0; i < 10; i = i + 1) {\n";
ultimateProgram = ultimateProgram + " push(array, i * i);\n";
ultimateProgram = ultimateProgram + " array[i] = array[i] + 1;\n";
ultimateProgram = ultimateProgram + "}\n";
ultimateProgram = ultimateProgram + "print(\"Array length: \" + toString(len(array)));\n";
ultimateProgram = ultimateProgram + "print(\"Array[5]: \" + toString(array[5]));\n";
ultimateProgram = ultimateProgram + "var popped = pop(array);\n";
ultimateProgram = ultimateProgram + "print(\"Popped value: \" + toString(popped));\n";
ultimateProgram = ultimateProgram + "print(\"✅ Array operations complete\");\n";
// Test 3: Dictionary operations
ultimateProgram = ultimateProgram + "print(\"\\n📊 TEST 3: Dictionary Operations\");\n";
ultimateProgram = ultimateProgram + "for (var i = 0; i < 10; i = i + 1) {\n";
ultimateProgram = ultimateProgram + " dict[\"key_\" + toString(i)] = i * 2;\n";
ultimateProgram = ultimateProgram + " dict[\"nested_\" + toString(i)] = {\"value\": i * 3, \"squared\": i * i};\n";
ultimateProgram = ultimateProgram + "}\n";
ultimateProgram = ultimateProgram + "print(\"Dict length: \" + toString(len(dict)));\n";
ultimateProgram = ultimateProgram + "print(\"Dict key_5: \" + toString(dict[\"key_5\"]));\n";
ultimateProgram = ultimateProgram + "var dictKeys = keys(dict);\n";
ultimateProgram = ultimateProgram + "var dictValues = values(dict);\n";
ultimateProgram = ultimateProgram + "print(\"Keys length: \" + toString(len(dictKeys)));\n";
ultimateProgram = ultimateProgram + "print(\"Values length: \" + toString(len(dictValues)));\n";
ultimateProgram = ultimateProgram + "print(\"Has key_5: \" + toString(has(dict, \"key_5\")));\n";
ultimateProgram = ultimateProgram + "print(\"✅ Dictionary operations complete\");\n";
// Test 4: String operations and indexing
ultimateProgram = ultimateProgram + "print(\"\\n📊 TEST 4: String Operations\");\n";
ultimateProgram = ultimateProgram + "var testString = \"Ultimate Bob Programming Language\";\n";
ultimateProgram = ultimateProgram + "print(\"Original string: \" + testString);\n";
ultimateProgram = ultimateProgram + "print(\"String length: \" + toString(len(testString)));\n";
ultimateProgram = ultimateProgram + "print(\"Character by character:\");\n";
ultimateProgram = ultimateProgram + "for (var i = 0; i < len(testString); i = i + 1) {\n";
ultimateProgram = ultimateProgram + " print(\" \" + toString(i) + \": '\" + testString[i] + \"'\");\n";
ultimateProgram = ultimateProgram + "}\n";
ultimateProgram = ultimateProgram + "print(\"✅ String operations complete\");\n";
// Test 5: Function definitions and calls
ultimateProgram = ultimateProgram + "print(\"\\n📊 TEST 5: Function Operations\");\n";
ultimateProgram = ultimateProgram + "func factorial(n) {\n";
ultimateProgram = ultimateProgram + " if (n <= 1) {\n";
ultimateProgram = ultimateProgram + " return 1;\n";
ultimateProgram = ultimateProgram + " } else {\n";
ultimateProgram = ultimateProgram + " return n * factorial(n - 1);\n";
ultimateProgram = ultimateProgram + " }\n";
ultimateProgram = ultimateProgram + "}\n";
ultimateProgram = ultimateProgram + "func fibonacci(n) {\n";
ultimateProgram = ultimateProgram + " if (n <= 1) {\n";
ultimateProgram = ultimateProgram + " return n;\n";
ultimateProgram = ultimateProgram + " } else {\n";
ultimateProgram = ultimateProgram + " return fibonacci(n - 1) + fibonacci(n - 2);\n";
ultimateProgram = ultimateProgram + " }\n";
ultimateProgram = ultimateProgram + "}\n";
ultimateProgram = ultimateProgram + "var fact5 = factorial(5);\n";
ultimateProgram = ultimateProgram + "var fib8 = fibonacci(8);\n";
ultimateProgram = ultimateProgram + "print(\"Factorial(5): \" + toString(fact5));\n";
ultimateProgram = ultimateProgram + "print(\"Fibonacci(8): \" + toString(fib8));\n";
ultimateProgram = ultimateProgram + "print(\"✅ Function operations complete\");\n";
// Test 6: Built-in functions
ultimateProgram = ultimateProgram + "print(\"\\n📊 TEST 6: Built-in Functions\");\n";
ultimateProgram = ultimateProgram + "var currentTime = time();\n";
ultimateProgram = ultimateProgram + "print(\"Current time: \" + toString(currentTime));\n";
ultimateProgram = ultimateProgram + "var randomNum = random();\n";
ultimateProgram = ultimateProgram + "print(\"Random number: \" + toString(randomNum));\n";
ultimateProgram = ultimateProgram + "var numberStr = toString(12345);\n";
ultimateProgram = ultimateProgram + "print(\"Number to string: '\" + numberStr + \"'\");\n";
ultimateProgram = ultimateProgram + "var strNum = toNumber(\"678\");\n";
ultimateProgram = ultimateProgram + "print(\"String to number: \" + toString(strNum));\n";
ultimateProgram = ultimateProgram + "print(\"✅ Built-in functions complete\");\n";
// Test 7: Nested eval (meta-programming)
ultimateProgram = ultimateProgram + "print(\"\\n📊 TEST 7: Meta-programming with Eval\");\n";
ultimateProgram = ultimateProgram + "var evalCode = \"print(\\\"Hello from nested eval!\\\"); var x = 5 * 5; print(\\\"x = \\\" + toString(x));\";\n";
ultimateProgram = ultimateProgram + "var evalResult = eval(evalCode);\n";
ultimateProgram = ultimateProgram + "print(\"✅ Meta-programming complete\");\n";
// Test 8: Complex data structures
ultimateProgram = ultimateProgram + "print(\"\\n📊 TEST 8: Complex Data Structures\");\n";
ultimateProgram = ultimateProgram + "var complexArray = [];\n";
ultimateProgram = ultimateProgram + "for (var i = 0; i < 5; i = i + 1) {\n";
ultimateProgram = ultimateProgram + " var innerArray = [];\n";
ultimateProgram = ultimateProgram + " for (var j = 0; j < 3; j = j + 1) {\n";
ultimateProgram = ultimateProgram + " push(innerArray, i * j);\n";
ultimateProgram = ultimateProgram + " }\n";
ultimateProgram = ultimateProgram + " push(complexArray, innerArray);\n";
ultimateProgram = ultimateProgram + "}\n";
ultimateProgram = ultimateProgram + "print(\"Complex array length: \" + toString(len(complexArray)));\n";
ultimateProgram = ultimateProgram + "print(\"Complex array[2][1]: \" + toString(complexArray[2][1]));\n";
ultimateProgram = ultimateProgram + "print(\"✅ Complex data structures complete\");\n";
// Test 9: Error handling and edge cases
ultimateProgram = ultimateProgram + "print(\"\\n📊 TEST 9: Edge Cases\");\n";
ultimateProgram = ultimateProgram + "var emptyArray = [];\n";
ultimateProgram = ultimateProgram + "print(\"Empty array length: \" + toString(len(emptyArray)));\n";
ultimateProgram = ultimateProgram + "var emptyDict = {};\n";
ultimateProgram = ultimateProgram + "print(\"Empty dict length: \" + toString(len(emptyDict)));\n";
ultimateProgram = ultimateProgram + "print(\"Empty string length: \" + toString(len(\"\")));\n";
ultimateProgram = ultimateProgram + "print(\"✅ Edge cases complete\");\n";
// Final summary
ultimateProgram = ultimateProgram + "print(\"\\n🎉 ULTIMATE REGRESSION TEST SUMMARY\");\n";
ultimateProgram = ultimateProgram + "print(\"✅ All basic types tested\");\n";
ultimateProgram = ultimateProgram + "print(\"✅ All array operations tested\");\n";
ultimateProgram = ultimateProgram + "print(\"✅ All dictionary operations tested\");\n";
ultimateProgram = ultimateProgram + "print(\"✅ All string operations tested\");\n";
ultimateProgram = ultimateProgram + "print(\"✅ All function operations tested\");\n";
ultimateProgram = ultimateProgram + "print(\"✅ All built-in functions tested\");\n";
ultimateProgram = ultimateProgram + "print(\"✅ Meta-programming with eval tested\");\n";
ultimateProgram = ultimateProgram + "print(\"✅ Complex data structures tested\");\n";
ultimateProgram = ultimateProgram + "print(\"✅ Edge cases tested\");\n";
ultimateProgram = ultimateProgram + "print(\"\\n🏆 ULTIMATE REGRESSION TEST PASSED!\");\n";
ultimateProgram = ultimateProgram + "print(\"🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE!\");\n";
// ========================================
// PHASE 2: WRITE TO FILE
// ========================================
print("\n📝 PHASE 2: Writing ultimate program to file...");
writeFile("ultimate_regression_dynamic.bob", ultimateProgram);
print("✅ Ultimate program written to file");
// ========================================
// PHASE 3: LOAD AND VERIFY
// ========================================
print("\n📂 PHASE 3: Loading and verifying...");
var fileExists = fileExists("ultimate_regression_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
var loadedUltimate = readFile("ultimate_regression_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedUltimate)) + " characters");
// ========================================
// PHASE 4: EXECUTE THE ULTIMATE PROGRAM
// ========================================
print("\n⚡ PHASE 4: Executing the ultimate program...");
print("🚀 STARTING ULTIMATE REGRESSION BUSTER...");
print("🔥 PREPARE FOR THE MOST COMPLEX TEST EVER! 🔥");
var ultimateResult = eval(loadedUltimate);
print("\n🎊 ULTIMATE EXECUTION COMPLETE!");
print("✅ The most complex regression test ever executed successfully!");
print("✅ Every feature of Bob was tested!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire ultimate program!");
} else {
print("❌ ERROR: Ultimate file not found!");
}
// ========================================
// FINAL VERIFICATION
// ========================================
print("\n🔍 FINAL VERIFICATION...");
var verificationFile = readFile("ultimate_regression_dynamic.bob");
print(" Ultimate file length: " + toString(len(verificationFile)) + " characters");
print(" File contains ultimate program: " + toString(len(verificationFile) > 1000));
// ========================================
// ULTIMATE SUMMARY
// ========================================
print("\n🎉 ULTIMATE REGRESSION TEST COMPLETE!");
print("✅ Successfully created the most complex Bob program ever!");
print("✅ Successfully wrote it to file with file I/O!");
print("✅ Successfully loaded it with file I/O!");
print("✅ Successfully executed it with eval!");
print("✅ Every single feature of Bob was tested!");
print("✅ All features work together perfectly!");
print("\n🏆 ULTIMATE ACHIEVEMENT UNLOCKED!");
print("🚀 BOB CAN HANDLE ANY COMPLEXITY!");
print("🔥 BOB IS UNSTOPPABLE!");
print("💪 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE!");
print("\n🎊 THE ULTIMATE REGRESSION TEST IS COMPLETE! 🎊");
print("🌟 BOB HAS REACHED ULTIMATE POWER! 🌟");

106
ultimate_regression_dynamic.bob
View File

@ -1,106 +0,0 @@
print("=== ULTIMATE REGRESSION BUSTER ===");
print("Testing EVERY feature with maximum complexity...");
print("\n📊 TEST 1: Basic Types");
var number = 42;
var string = "Hello, Ultimate Bob!";
var boolean = true;
var array = [];
var dict = {};
print("✅ Basic types created");
print("\n📊 TEST 2: Array Operations");
for (var i = 0; i < 10; i = i + 1) {
push(array, i * i);
array[i] = array[i] + 1;
}
print("Array length: " + toString(len(array)));
print("Array[5]: " + toString(array[5]));
var popped = pop(array);
print("Popped value: " + toString(popped));
print("✅ Array operations complete");
print("\n📊 TEST 3: Dictionary Operations");
for (var i = 0; i < 10; i = i + 1) {
dict["key_" + toString(i)] = i * 2;
dict["nested_" + toString(i)] = {"value": i * 3, "squared": i * i};
}
print("Dict length: " + toString(len(dict)));
print("Dict key_5: " + toString(dict["key_5"]));
var dictKeys = keys(dict);
var dictValues = values(dict);
print("Keys length: " + toString(len(dictKeys)));
print("Values length: " + toString(len(dictValues)));
print("Has key_5: " + toString(has(dict, "key_5")));
print("✅ Dictionary operations complete");
print("\n📊 TEST 4: String Operations");
var testString = "Ultimate Bob Programming Language";
print("Original string: " + testString);
print("String length: " + toString(len(testString)));
print("Character by character:");
for (var i = 0; i < len(testString); i = i + 1) {
print(" " + toString(i) + ": '" + testString[i] + "'");
}
print("✅ String operations complete");
print("\n📊 TEST 5: Function Operations");
func factorial(n) {
if (n <= 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
func fibonacci(n) {
if (n <= 1) {
return n;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
var fact5 = factorial(5);
var fib8 = fibonacci(8);
print("Factorial(5): " + toString(fact5));
print("Fibonacci(8): " + toString(fib8));
print("✅ Function operations complete");
print("\n📊 TEST 6: Built-in Functions");
var currentTime = time();
print("Current time: " + toString(currentTime));
var randomNum = random();
print("Random number: " + toString(randomNum));
var numberStr = toString(12345);
print("Number to string: '" + numberStr + "'");
var strNum = toNumber("678");
print("String to number: " + toString(strNum));
print("✅ Built-in functions complete");
print("\n📊 TEST 7: Meta-programming with Eval");
var evalCode = "print(\"Hello from nested eval!\"); var x = 5 * 5; print(\"x = \" + toString(x));";
var evalResult = eval(evalCode);
print("✅ Meta-programming complete");
print("\n📊 TEST 8: Complex Data Structures");
var complexArray = [];
for (var i = 0; i < 5; i = i + 1) {
var innerArray = [];
for (var j = 0; j < 3; j = j + 1) {
push(innerArray, i * j);
}
push(complexArray, innerArray);
}
print("Complex array length: " + toString(len(complexArray)));
print("Complex array[2][1]: " + toString(complexArray[2][1]));
print("✅ Complex data structures complete");
print("\n📊 TEST 9: Edge Cases");
var emptyArray = [];
print("Empty array length: " + toString(len(emptyArray)));
var emptyDict = {};
print("Empty dict length: " + toString(len(emptyDict)));
print("Empty string length: " + toString(len("")));
print("✅ Edge cases complete");
print("\n🎉 ULTIMATE REGRESSION TEST SUMMARY");
print("✅ All basic types tested");
print("✅ All array operations tested");
print("✅ All dictionary operations tested");
print("✅ All string operations tested");
print("✅ All function operations tested");
print("✅ All built-in functions tested");
print("✅ Meta-programming with eval tested");
print("✅ Complex data structures tested");
print("✅ Edge cases tested");
print("\n🏆 ULTIMATE REGRESSION TEST PASSED!");
print("🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE!");

254
ultimate_regression_test.bob
View File

@ -1,254 +0,0 @@
print("=== ULTIMATE REGRESSION TEST ===");
print("Writing complex program to file, then loading and running it...");
// ========================================
// PHASE 1: WRITE COMPLEX PROGRAM TO FILE
// ========================================
print("\n📝 PHASE 1: Writing complex program to file...");
var programCode = "print(\"=== ULTIMATE REGRESSION BUSTER ===\");";
programCode = programCode + "print(\"Testing ALL features together...\");";
// Add massive variable declarations
programCode = programCode + "var megaArray = [];";
programCode = programCode + "var megaDict = {};";
programCode = programCode + "var megaString = \"ULTIMATE_TEST_STRING\";";
programCode = programCode + "var megaNumber = 999999999.999999999;";
programCode = programCode + "var megaBoolean = true;";
programCode = programCode + "var megaNone = none;";
// Add complex nested structures
programCode = programCode + "for (var i = 0; i < 100; i = i + 1) {";
programCode = programCode + "var nestedArray = [];";
programCode = programCode + "var nestedDict = {};";
programCode = programCode + "for (var j = 0; j < 10; j = j + 1) {";
programCode = programCode + "push(nestedArray, \"nested_\" + toString(i) + \"_\" + toString(j));";
programCode = programCode + "nestedDict[\"key_\" + toString(i) + \"_\" + toString(j)] = \"value_\" + toString(i) + \"_\" + toString(j);";
programCode = programCode + "}";
programCode = programCode + "push(megaArray, nestedArray);";
programCode = programCode + "megaDict[\"dict_\" + toString(i)] = nestedDict;";
programCode = programCode + "}";
// Add function generation
programCode = programCode + "for (var funcIndex = 0; funcIndex < 50; funcIndex = funcIndex + 1) {";
programCode = programCode + "var funcName = \"megaFunc_\" + toString(funcIndex);";
programCode = programCode + "var funcCode = \"func \" + funcName + \"(a, b, c, d, e) { \";";
programCode = programCode + "funcCode = funcCode + \"var result = a + b * c - d / e; \";";
programCode = programCode + "funcCode = funcCode + \"if (result > 1000) { \";";
programCode = programCode + "funcCode = funcCode + \"return result * 2; \";";
programCode = programCode + "funcCode = funcCode + \"} else { \";";
programCode = programCode + "funcCode = funcCode + \"return result / 2; \";";
programCode = programCode + "funcCode = funcCode + \"} \";";
programCode = programCode + "funcCode = funcCode + \"} \";";
programCode = programCode + "eval(funcCode);";
programCode = programCode + "var testResult = eval(funcName + \"(10, 20, 30, 5, 2)\");";
programCode = programCode + "print(\"Generated and tested \" + funcName + \": \" + toString(testResult));";
programCode = programCode + "}";
// Add string indexing madness
programCode = programCode + "var complexString = \"Hello, Bob Language! This is a ULTIMATE test with numbers 12345\";";
programCode = programCode + "var stringAnalysis = {};";
programCode = programCode + "for (var i = 0; i < len(complexString); i = i + 1) {";
programCode = programCode + "var char = complexString[i];";
programCode = programCode + "var charInfo = {};";
programCode = programCode + "charInfo[\"character\"] = char;";
programCode = programCode + "charInfo[\"index\"] = i;";
programCode = programCode + "charInfo[\"ascii_approx\"] = i * 2 + 32;";
programCode = programCode + "if (char == \" \") { charInfo[\"type\"] = \"space\"; }";
programCode = programCode + "else if (char == \",\" || char == \"!\") { charInfo[\"type\"] = \"symbol\"; }";
programCode = programCode + "else if (char == \"0\" || char == \"1\" || char == \"2\" || char == \"3\" || char == \"4\" || char == \"5\" || char == \"6\" || char == \"7\" || char == \"8\" || char == \"9\") { charInfo[\"type\"] = \"digit\"; }";
programCode = programCode + "else if (char == \"H\" || char == \"B\" || char == \"L\") { charInfo[\"type\"] = \"uppercase\"; }";
programCode = programCode + "else { charInfo[\"type\"] = \"lowercase\"; }";
programCode = programCode + "stringAnalysis[\"char_\" + toString(i)] = charInfo;";
programCode = programCode + "}";
// Add recursive function torture
programCode = programCode + "func megaRecursiveTorture(n, depth, accumulator) {";
programCode = programCode + "if (depth > 50) { return accumulator; }";
programCode = programCode + "var currentString = \"depth_\" + toString(depth) + \"_value_\" + toString(n);";
programCode = programCode + "var reversedString = \"\";";
programCode = programCode + "for (var i = len(currentString) - 1; i >= 0; i = i - 1) {";
programCode = programCode + "reversedString = reversedString + currentString[i];";
programCode = programCode + "}";
programCode = programCode + "var tempArray = [];";
programCode = programCode + "for (var i = 0; i < depth; i = i + 1) {";
programCode = programCode + "push(tempArray, reversedString + \"_\" + toString(i));";
programCode = programCode + "}";
programCode = programCode + "var tempDict = {};";
programCode = programCode + "tempDict[\"depth\"] = depth;";
programCode = programCode + "tempDict[\"value\"] = n;";
programCode = programCode + "tempDict[\"string\"] = currentString;";
programCode = programCode + "tempDict[\"reversed\"] = reversedString;";
programCode = programCode + "tempDict[\"array\"] = tempArray;";
programCode = programCode + "push(accumulator, tempDict);";
programCode = programCode + "return megaRecursiveTorture(n * 2 + depth, depth + 1, accumulator);";
programCode = programCode + "}";
programCode = programCode + "var recursiveResult = megaRecursiveTorture(1, 0, []);";
// Add mega array operations
programCode = programCode + "var megaArray2 = [];";
programCode = programCode + "var megaArray3 = [];";
programCode = programCode + "for (var i = 0; i < 1000; i = i + 1) {";
programCode = programCode + "var complexValue = {};";
programCode = programCode + "complexValue[\"index\"] = i;";
programCode = programCode + "complexValue[\"square\"] = i * i;";
programCode = programCode + "complexValue[\"cube\"] = i * i * i;";
programCode = programCode + "complexValue[\"string\"] = \"value_\" + toString(i);";
programCode = programCode + "complexValue[\"array\"] = [i, i + 1, i + 2, i + 3, i + 4];";
programCode = programCode + "complexValue[\"dict\"] = {\"nested\": i, \"deep\": i * 2};";
programCode = programCode + "push(megaArray2, complexValue);";
programCode = programCode + "if (i % 2 == 0) { push(megaArray3, i * 2); } else { push(megaArray3, i * 3); }";
programCode = programCode + "}";
// Add mega eval torture
programCode = programCode + "for (var evalIndex = 0; evalIndex < 100; evalIndex = evalIndex + 1) {";
programCode = programCode + "var evalCode = \"var evalVar_\" + toString(evalIndex) + \" = \" + toString(evalIndex) + \" * \" + toString(evalIndex) + \" + \" + toString(evalIndex) + \";\";";
programCode = programCode + "evalCode = evalCode + \"var evalString_\" + toString(evalIndex) + \" = \\\"eval_string_\" + toString(evalIndex) + \"\\\";\";";
programCode = programCode + "evalCode = evalCode + \"var evalArray_\" + toString(evalIndex) + \" = [\" + toString(evalIndex) + \", \" + toString(evalIndex + 1) + \", \" + toString(evalIndex + 2) + \"];\";";
programCode = programCode + "evalCode = evalCode + \"var evalResult_\" + toString(evalIndex) + \" = evalVar_\" + toString(evalIndex) + \" + len(evalString_\" + toString(evalIndex) + \") + len(evalArray_\" + toString(evalIndex) + \");\";";
programCode = programCode + "evalCode = evalCode + \"evalResult_\" + toString(evalIndex);";
programCode = programCode + "var evalResult = eval(evalCode);";
programCode = programCode + "if (evalIndex % 10 == 0) {";
programCode = programCode + "print(\"Eval torture progress: \" + toString(evalIndex) + \"/100\");";
programCode = programCode + "}";
programCode = programCode + "}";
// Add mega loop torture
programCode = programCode + "var loopResults = [];";
programCode = programCode + "var loopCounter = 0;";
programCode = programCode + "for (var i = 0; i < 100; i = i + 1) {";
programCode = programCode + "for (var j = 0; j < 50; j = j + 1) {";
programCode = programCode + "for (var k = 0; k < 25; k = k + 1) {";
programCode = programCode + "var loopValue = i * j * k;";
programCode = programCode + "var loopString = \"loop_\" + toString(i) + \"_\" + toString(j) + \"_\" + toString(k);";
programCode = programCode + "var reversedString = \"\";";
programCode = programCode + "for (var l = 0; l < len(loopString); l = l + 1) {";
programCode = programCode + "reversedString = reversedString + loopString[len(loopString) - 1 - l];";
programCode = programCode + "}";
programCode = programCode + "var loopObject = {";
programCode = programCode + "\"value\": loopValue,";
programCode = programCode + "\"string\": loopString,";
programCode = programCode + "\"reversed\": reversedString,";
programCode = programCode + "\"sum\": i + j + k";
programCode = programCode + "};";
programCode = programCode + "push(loopResults, loopObject);";
programCode = programCode + "loopCounter = loopCounter + 1;";
programCode = programCode + "}";
programCode = programCode + "}";
programCode = programCode + "}";
// Add final summary
programCode = programCode + "print(\"🎉 ULTIMATE REGRESSION BUSTER COMPLETE!\");";
programCode = programCode + "print(\"✅ All phases completed successfully!\");";
programCode = programCode + "print(\"✅ Every feature tested against every other feature!\");";
programCode = programCode + "print(\"✅ Maximum complexity achieved!\");";
programCode = programCode + "print(\"✅ No regressions detected!\");";
programCode = programCode + "print(\"📊 FINAL STATISTICS:\");";
programCode = programCode + "print(\" • Variables created: 1000+\");";
programCode = programCode + "print(\" • Functions generated: 50+\");";
programCode = programCode + "print(\" • Arrays processed: 5000+ elements\");";
programCode = programCode + "print(\" • Dictionaries created: 1000+ entries\");";
programCode = programCode + "print(\" • String characters processed: 1000+\");";
programCode = programCode + "print(\" • Eval statements executed: 100+\");";
programCode = programCode + "print(\" • Loop iterations: 125,000+\");";
programCode = programCode + "print(\" • Conditional checks: 1000+\");";
programCode = programCode + "print(\" • Arithmetic operations: 10,000+\");";
programCode = programCode + "print(\" • Type conversions: 500+\");";
programCode = programCode + "print(\"🏆 ULTIMATE REGRESSION TEST PASSED!\");";
programCode = programCode + "print(\"Bob is ROCK SOLID under maximum stress!\");";
programCode = programCode + "print(\"All features work perfectly together!\");";
programCode = programCode + "print(\"Ready for production use!\");";
programCode = programCode + "print(\"🚀 BOB IS UNSTOPPABLE! 🚀\");";
programCode = programCode + "print(\"🎊 ULTIMATE REGRESSION BUSTER COMPLETE! 🎊\");";
// Write the program to a file
writeFile("ultimate_regression_dynamic.bob", programCode);
print("✅ Complex program written to file: ultimate_regression_dynamic.bob");
// ========================================
// PHASE 2: LOAD AND RUN THE PROGRAM
// ========================================
print("\n📂 PHASE 2: Loading and running the program...");
// Check if file exists
var fileExists = fileExists("ultimate_regression_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
// Read the file content
var loadedCode = readFile("ultimate_regression_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// Use eval to run the loaded code
print("\n⚡ PHASE 3: Executing program with eval...");
print("🚀 STARTING ULTIMATE REGRESSION BUSTER...");
var evalResult = eval(loadedCode);
print("\n✅ PROGRAM EXECUTION COMPLETE!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire program!");
print("✅ All features tested successfully!");
} else {
print("❌ ERROR: File not found!");
}
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification...");
// Verify the file was created and has content
var verificationFile = readFile("ultimate_regression_dynamic.bob");
var fileLength = len(verificationFile);
print(" Verification file length: " + toString(fileLength) + " characters");
print(" File contains complex program: " + toString(len(verificationFile) > 1000));
// Check for key elements in the file
var containsPrint = false;
var containsFunc = false;
var containsEval = false;
for (var i = 0; i < len(verificationFile); i = i + 1) {
var char = verificationFile[i];
if (char == "p" && i + 4 < len(verificationFile)) {
if (verificationFile[i + 1] == "r" && verificationFile[i + 2] == "i" && verificationFile[i + 3] == "n" && verificationFile[i + 4] == "t") {
containsPrint = true;
}
}
if (char == "f" && i + 3 < len(verificationFile)) {
if (verificationFile[i + 1] == "u" && verificationFile[i + 2] == "n" && verificationFile[i + 3] == "c") {
containsFunc = true;
}
}
if (char == "e" && i + 2 < len(verificationFile)) {
if (verificationFile[i + 1] == "v" && verificationFile[i + 2] == "a" && verificationFile[i + 3] == "l") {
containsEval = true;
}
}
}
print(" Contains print statements: " + toString(containsPrint));
print(" Contains function definitions: " + toString(containsFunc));
print(" Contains eval statements: " + toString(containsEval));
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 ULTIMATE REGRESSION TEST COMPLETE!");
print("✅ Successfully wrote complex program to file");
print("✅ Successfully loaded file with file I/O");
print("✅ Successfully executed with eval");
print("✅ All features working together perfectly!");
print("\n🏆 ULTIMATE TEST PASSED!");
print("Bob can write complex programs to files!");
print("Bob can read files with file I/O!");
print("Bob can execute loaded code with eval!");
print("Bob is UNSTOPPABLE!");
print("\n🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE! 🚀");
print("🎊 ULTIMATE REGRESSION TEST COMPLETE! 🎊");

56
working_regression.bob
View File

@ -1,56 +0,0 @@
print("=== WORKING REGRESSION TEST ===");
// Phase 1: Create a working program step by step
print("Phase 1: Building working program...");
var program = "";
program = program + "print(\"=== REGRESSION BUSTER ===\");\n";
program = program + "print(\"Testing core features...\");\n";
// Add basic variables
program = program + "var testArray = [];\n";
program = program + "var testDict = {};\n";
program = program + "var testString = \"Hello, Bob!\";\n";
// Add array operations
program = program + "for (var i = 0; i < 5; i = i + 1) {\n";
program = program + " push(testArray, i * i);\n";
program = program + " testDict[\"key_\" + toString(i)] = i * 2;\n";
program = program + "}\n";
// Add string indexing
program = program + "print(\"String: \" + testString);\n";
program = program + "print(\"First char: \" + testString[0]);\n";
// Add function
program = program + "func testFunc(x) { return x * 2; }\n";
program = program + "var result = testFunc(10);\n";
program = program + "print(\"Function result: \" + toString(result));\n";
// Add final summary
program = program + "print(\"Array length: \" + toString(len(testArray)));\n";
program = program + "print(\"Dict length: \" + toString(len(testDict)));\n";
program = program + "print(\"✅ REGRESSION TEST PASSED!\");\n";
// Phase 2: Write to file
print("Phase 2: Writing to file...");
writeFile("working_regression_dynamic.bob", program);
print("✅ File written successfully");
// Phase 3: Read and verify
print("Phase 3: Reading file...");
var loadedProgram = readFile("working_regression_dynamic.bob");
print("✅ File read successfully");
print("File size: " + toString(len(loadedProgram)) + " characters");
// Phase 4: Execute with eval
print("Phase 4: Executing with eval...");
print("🚀 STARTING REGRESSION BUSTER...");
var evalResult = eval(loadedProgram);
print("✅ Eval completed successfully!");
print("🎉 WORKING REGRESSION TEST COMPLETE!");
print("✅ All phases completed successfully!");
print("✅ File I/O working!");
print("✅ Eval working!");
print("✅ All features tested!");

17
working_regression_dynamic.bob
View File

@ -1,17 +0,0 @@
print("=== REGRESSION BUSTER ===");
print("Testing core features...");
var testArray = [];
var testDict = {};
var testString = "Hello, Bob!";
for (var i = 0; i < 5; i = i + 1) {
push(testArray, i * i);
testDict["key_" + toString(i)] = i * 2;
}
print("String: " + testString);
print("First char: " + testString[0]);
func testFunc(x) { return x * 2; }
var result = testFunc(10);
print("Function result: " + toString(result));
print("Array length: " + toString(len(testArray)));
print("Dict length: " + toString(len(testDict)));
print("✅ REGRESSION TEST PASSED!");

114
working_regression_final.bob
View File

@ -1,114 +0,0 @@
print("=== WORKING REGRESSION FINAL ===");
print("Creating a proper regression test that actually works...");
// ========================================
// PHASE 1: WRITE WORKING BOB CODE TO FILE
// ========================================
print("\n📝 PHASE 1: Writing working Bob code to file...");
// Create a properly formatted Bob program with correct syntax
var workingProgram = "print(\"=== WORKING REGRESSION BUSTER ===\");\n";
workingProgram = workingProgram + "print(\"Testing ALL features with working syntax...\");\n";
// Add basic variable declarations
workingProgram = workingProgram + "var testArray = [];\n";
workingProgram = workingProgram + "var testDict = {};\n";
workingProgram = workingProgram + "var testString = \"Hello, Bob!\";\n";
workingProgram = workingProgram + "var testNumber = 42;\n";
workingProgram = workingProgram + "var testBoolean = true;\n";
// Add array operations
workingProgram = workingProgram + "for (var i = 0; i < 10; i = i + 1) {\n";
workingProgram = workingProgram + " push(testArray, i * i);\n";
workingProgram = workingProgram + " testDict[\"key_\" + toString(i)] = i * 2;\n";
workingProgram = workingProgram + "}\n";
// Add string indexing
workingProgram = workingProgram + "print(\"String indexing test:\");\n";
workingProgram = workingProgram + "for (var i = 0; i < len(testString); i = i + 1) {\n";
workingProgram = workingProgram + " print(\"Character \" + toString(i) + \": \" + testString[i]);\n";
workingProgram = workingProgram + "}\n";
// Add function definition
workingProgram = workingProgram + "func testFunction(x, y) {\n";
workingProgram = workingProgram + " return x + y * 2;\n";
workingProgram = workingProgram + "}\n";
workingProgram = workingProgram + "var result = testFunction(5, 10);\n";
workingProgram = workingProgram + "print(\"Function result: \" + toString(result));\n";
// Add eval test
workingProgram = workingProgram + "var evalResult = eval(\"5 * 5 + 10\");\n";
workingProgram = workingProgram + "print(\"Eval result: \" + toString(evalResult));\n";
// Add final summary
workingProgram = workingProgram + "print(\"✅ All core features working!\");\n";
workingProgram = workingProgram + "print(\"✅ Arrays: \" + toString(len(testArray)) + \" elements\");\n";
workingProgram = workingProgram + "print(\"✅ Dictionaries: \" + toString(len(testDict)) + \" entries\");\n";
workingProgram = workingProgram + "print(\"✅ String indexing: \" + toString(len(testString)) + \" characters\");\n";
workingProgram = workingProgram + "print(\"✅ Functions: working\");\n";
workingProgram = workingProgram + "print(\"✅ Eval: working\");\n";
workingProgram = workingProgram + "print(\"🎉 WORKING REGRESSION TEST PASSED!\");\n";
// Write the working program to a file
writeFile("working_regression_dynamic.bob", workingProgram);
print("✅ Working Bob code written to file: working_regression_dynamic.bob");
// ========================================
// PHASE 2: LOAD AND RUN THE WORKING PROGRAM
// ========================================
print("\n📂 PHASE 2: Loading and running the working program...");
// Check if file exists
var fileExists = fileExists("working_regression_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
// Read the file content
var loadedCode = readFile("working_regression_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// Use eval to run the loaded code
print("\n⚡ PHASE 3: Executing working program with eval...");
print("🚀 STARTING WORKING REGRESSION BUSTER...");
var evalResult = eval(loadedCode);
print("\n✅ PROGRAM EXECUTION COMPLETE!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire program!");
print("✅ All features tested successfully!");
} else {
print("❌ ERROR: File not found!");
}
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification...");
// Verify the file was created and has content
var verificationFile = readFile("working_regression_dynamic.bob");
var fileLength = len(verificationFile);
print(" Verification file length: " + toString(fileLength) + " characters");
print(" File contains working program: " + toString(len(verificationFile) > 100));
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 WORKING REGRESSION FINAL COMPLETE!");
print("✅ Successfully wrote working Bob code to file");
print("✅ Successfully loaded file with file I/O");
print("✅ Successfully executed with eval");
print("✅ All features working together perfectly!");
print("\n🏆 WORKING TEST PASSED!");
print("Bob can write working programs to files!");
print("Bob can read files with file I/O!");
print("Bob can execute loaded code with eval!");
print("Bob is UNSTOPPABLE!");
print("\n🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE! 🚀");
print("🎊 WORKING REGRESSION FINAL COMPLETE! 🎊");

180
working_regression_test.bob
View File

@ -1,180 +0,0 @@
print("=== WORKING REGRESSION TEST ===");
print("Demonstrating file I/O and eval with a simple but effective approach...");
// ========================================
// PHASE 1: WRITE A SIMPLE BUT EFFECTIVE PROGRAM
// ========================================
print("\n📝 PHASE 1: Writing simple program to file...");
// Create a simple but comprehensive test program
var simpleProgram = "print(\"=== SIMPLE REGRESSION BUSTER ===\");\n";
simpleProgram = simpleProgram + "print(\"Testing core features...\");\n";
// Add basic variable declarations
simpleProgram = simpleProgram + "var testArray = [];\n";
simpleProgram = simpleProgram + "var testDict = {};\n";
simpleProgram = simpleProgram + "var testString = \"Hello, Bob!\";\n";
simpleProgram = simpleProgram + "var testNumber = 42;\n";
simpleProgram = simpleProgram + "var testBoolean = true;\n";
// Add array operations
simpleProgram = simpleProgram + "for (var i = 0; i < 10; i = i + 1) {\n";
simpleProgram = simpleProgram + "push(testArray, i * i);\n";
simpleProgram = simpleProgram + "testDict[\"key_\" + toString(i)] = i * 2;\n";
simpleProgram = simpleProgram + "}\n";
// Add string indexing
simpleProgram = simpleProgram + "print(\"String indexing test:\");\n";
simpleProgram = simpleProgram + "for (var i = 0; i < len(testString); i = i + 1) {\n";
simpleProgram = simpleProgram + "print(\"Character \" + toString(i) + \": \" + testString[i]);\n";
simpleProgram = simpleProgram + "}\n";
// Add function definition and call
simpleProgram = simpleProgram + "func testFunction(x, y) {\n";
simpleProgram = simpleProgram + "return x + y * 2;\n";
simpleProgram = simpleProgram + "}\n";
simpleProgram = simpleProgram + "var result = testFunction(5, 10);\n";
simpleProgram = simpleProgram + "print(\"Function result: \" + toString(result));\n";
// Add eval test
simpleProgram = simpleProgram + "var evalResult = eval(\"5 * 5 + 10\");\n";
simpleProgram = simpleProgram + "print(\"Eval result: \" + toString(evalResult));\n";
// Add final summary
simpleProgram = simpleProgram + "print(\"✅ All core features working!\");\n";
simpleProgram = simpleProgram + "print(\"✅ Arrays: \" + toString(len(testArray)) + \" elements\");\n";
simpleProgram = simpleProgram + "print(\"✅ Dictionaries: \" + toString(len(testDict)) + \" entries\");\n";
simpleProgram = simpleProgram + "print(\"✅ String indexing: \" + toString(len(testString)) + \" characters\");\n";
simpleProgram = simpleProgram + "print(\"✅ Functions: working\");\n";
simpleProgram = simpleProgram + "print(\"✅ Eval: working\");\n";
simpleProgram = simpleProgram + "print(\"🎉 SIMPLE REGRESSION TEST PASSED!\");\n";
// Write the program to a file
writeFile("simple_regression_dynamic.bob", simpleProgram);
print("✅ Simple program written to file: simple_regression_dynamic.bob");
// ========================================
// PHASE 2: LOAD AND RUN THE PROGRAM
// ========================================
print("\n📂 PHASE 2: Loading and running the program...");
// Check if file exists
var fileExists = fileExists("simple_regression_dynamic.bob");
print(" File exists: " + toString(fileExists));
if (fileExists) {
// Read the file content
var loadedCode = readFile("simple_regression_dynamic.bob");
print(" File loaded successfully!");
print(" File size: " + toString(len(loadedCode)) + " characters");
// Use eval to run the loaded code
print("\n⚡ PHASE 3: Executing program with eval...");
print("🚀 STARTING SIMPLE REGRESSION BUSTER...");
var evalResult = eval(loadedCode);
print("\n✅ PROGRAM EXECUTION COMPLETE!");
print("✅ File I/O worked perfectly!");
print("✅ Eval executed the entire program!");
print("✅ All features tested successfully!");
} else {
print("❌ ERROR: File not found!");
}
// ========================================
// PHASE 4: VERIFICATION
// ========================================
print("\n🔍 PHASE 4: Verification...");
// Verify the file was created and has content
var verificationFile = readFile("simple_regression_dynamic.bob");
var fileLength = len(verificationFile);
print(" Verification file length: " + toString(fileLength) + " characters");
print(" File contains program: " + toString(len(verificationFile) > 100));
// Check for key elements in the file
var containsPrint = false;
var containsFunc = false;
var containsEval = false;
for (var i = 0; i < len(verificationFile); i = i + 1) {
var char = verificationFile[i];
if (char == "p" && i + 4 < len(verificationFile)) {
if (verificationFile[i + 1] == "r" && verificationFile[i + 2] == "i" && verificationFile[i + 3] == "n" && verificationFile[i + 4] == "t") {
containsPrint = true;
}
}
if (char == "f" && i + 3 < len(verificationFile)) {
if (verificationFile[i + 1] == "u" && verificationFile[i + 2] == "n" && verificationFile[i + 3] == "c") {
containsFunc = true;
}
}
if (char == "e" && i + 2 < len(verificationFile)) {
if (verificationFile[i + 1] == "v" && verificationFile[i + 2] == "a" && verificationFile[i + 3] == "l") {
containsEval = true;
}
}
}
print(" Contains print statements: " + toString(containsPrint));
print(" Contains function definitions: " + toString(containsFunc));
print(" Contains eval statements: " + toString(containsEval));
// ========================================
// PHASE 5: DEMONSTRATE ALL FEATURES WORKING
// ========================================
print("\n🎯 PHASE 5: Demonstrating all features working...");
// Test arrays
var demoArray = [];
for (var i = 0; i < 5; i = i + 1) {
push(demoArray, i * i);
}
print(" Array test: " + toString(len(demoArray)) + " elements");
// Test dictionaries
var demoDict = {};
demoDict["key1"] = "value1";
demoDict["key2"] = "value2";
demoDict["key3"] = "value3";
print(" Dictionary test: " + toString(len(demoDict)) + " entries");
// Test string indexing
var demoString = "Hello, Bob!";
var reversedString = "";
for (var i = len(demoString) - 1; i >= 0; i = i - 1) {
reversedString = reversedString + demoString[i];
}
print(" String indexing test: " + demoString + " -> " + reversedString);
// Test functions
func demoFunction(a, b) {
return a + b * 2;
}
var funcResult = demoFunction(3, 4);
print(" Function test: demoFunction(3, 4) = " + toString(funcResult));
// Test eval
var evalTest = eval("10 * 5 + 20");
print(" Eval test: eval(\"10 * 5 + 20\") = " + toString(evalTest));
// ========================================
// FINAL SUMMARY
// ========================================
print("\n🎉 WORKING REGRESSION TEST COMPLETE!");
print("✅ Successfully wrote program to file");
print("✅ Successfully loaded file with file I/O");
print("✅ Successfully executed with eval");
print("✅ All features working together perfectly!");
print("\n🏆 WORKING TEST PASSED!");
print("Bob can write programs to files!");
print("Bob can read files with file I/O!");
print("Bob can execute loaded code with eval!");
print("Bob is UNSTOPPABLE!");
print("\n🚀 BOB IS THE ULTIMATE PROGRAMMING LANGUAGE! 🚀");
print("🎊 WORKING REGRESSION TEST COMPLETE! 🎊");