Step 403: self-host inference and generation coverage
This commit is contained in:
Bill
236
editor/tests/step403_test.cpp
Normal file
236
editor/tests/step403_test.cpp
Normal file
@@ -0,0 +1,236 @@
|
||||
// Step 403: Annotate + Generate from Self-Hosted AST (12 tests)
|
||||
|
||||
#include <cassert>
|
||||
#include <filesystem>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "AnnotationInference.h"
|
||||
#include "Pipeline.h"
|
||||
#include "SelfHostHarness.h"
|
||||
#include "SemannoFormat.h"
|
||||
#include "ast/Annotation.h"
|
||||
#include "ast/ClassDeclaration.h"
|
||||
#include "ast/Function.h"
|
||||
|
||||
namespace {
|
||||
|
||||
std::string resolvePath(const std::string& name) {
|
||||
const std::vector<std::string> candidates = {
|
||||
"src/" + name,
|
||||
"editor/src/" + name,
|
||||
"../src/" + name,
|
||||
"../../editor/src/" + name
|
||||
};
|
||||
for (const auto& candidate : candidates) {
|
||||
if (std::filesystem::exists(candidate)) return candidate;
|
||||
}
|
||||
return "src/" + name;
|
||||
}
|
||||
|
||||
std::string conflictHeaderPath() {
|
||||
static const std::string path = resolvePath("AnnotationConflictExtended.h");
|
||||
return path;
|
||||
}
|
||||
|
||||
std::string validatorHeaderPath() {
|
||||
static const std::string path = resolvePath("AnnotationValidatorExtended.h");
|
||||
return path;
|
||||
}
|
||||
|
||||
const ClassDeclaration* findClass(const Module* module, const std::string& name) {
|
||||
if (!module) return nullptr;
|
||||
for (auto* clsNode : module->getChildren("classes")) {
|
||||
auto* cls = static_cast<ClassDeclaration*>(clsNode);
|
||||
if (cls->name == name) return cls;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const Function* findMethod(const ClassDeclaration* cls, const std::string& name) {
|
||||
if (!cls) return nullptr;
|
||||
for (auto* methodNode : cls->getChildren("methods")) {
|
||||
if (methodNode->conceptType == "MethodDeclaration" || methodNode->conceptType == "Function") {
|
||||
auto* method = static_cast<Function*>(methodNode);
|
||||
if (method->name == name) return method;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
int countInferredType(const std::vector<AnnotationInference::InferredAnnotation>& inferred,
|
||||
const std::string& annotationType) {
|
||||
int count = 0;
|
||||
for (const auto& item : inferred) {
|
||||
if (item.annotationType == annotationType) count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
int main() {
|
||||
int passed = 0;
|
||||
|
||||
// Test 1: Parse real self-host headers from disk.
|
||||
{
|
||||
assert(std::filesystem::exists(conflictHeaderPath()));
|
||||
assert(std::filesystem::exists(validatorHeaderPath()));
|
||||
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||||
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||||
assert(conflict.parseSuccess && conflict.ast != nullptr);
|
||||
assert(validator.parseSuccess && validator.ast != nullptr);
|
||||
std::cout << "PASS: test 1 — parse both self-host headers\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 2: Inference on AnnotationConflictExtended AST returns signals.
|
||||
{
|
||||
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||||
AnnotationInference inf;
|
||||
auto inferred = inf.inferAll(conflict.ast.get());
|
||||
assert(!inferred.empty());
|
||||
std::cout << "PASS: test 2 — inference returns annotations for conflict AST\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 3: Inference on AnnotationValidatorExtended AST includes complexity signals.
|
||||
{
|
||||
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||||
AnnotationInference inf;
|
||||
auto inferred = inf.inferAll(validator.ast.get());
|
||||
assert(countInferredType(inferred, "ComplexityAnnotation") >= 1);
|
||||
std::cout << "PASS: test 3 — complexity inference on validator AST\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 4: Generate C++ from self-host conflict AST.
|
||||
{
|
||||
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||||
Pipeline pipeline;
|
||||
const std::string generated = pipeline.generate(conflict.ast.get(), "cpp");
|
||||
assert(!generated.empty());
|
||||
assert(generated.find("CrossTypeConflict") != std::string::npos);
|
||||
std::cout << "PASS: test 4 — generate C++ from conflict AST\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 5: Generate C++ from self-host validator AST.
|
||||
{
|
||||
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||||
Pipeline pipeline;
|
||||
const std::string generated = pipeline.generate(validator.ast.get(), "cpp");
|
||||
assert(!generated.empty());
|
||||
std::cout << "PASS: test 5 — generate C++ from validator AST\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 6: Conflict header roundtrip keeps struct and function structure.
|
||||
{
|
||||
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||||
Pipeline pipeline;
|
||||
const std::string generated = pipeline.generate(conflict.ast.get(), "cpp");
|
||||
assert(!generated.empty());
|
||||
auto roundtrip = SelfHostHarness::parseSource(generated, "conflict_roundtrip");
|
||||
assert(roundtrip.parseSuccess && roundtrip.ast != nullptr);
|
||||
std::cout << "PASS: test 6 — conflict parse/generate/parse roundtrip\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 7: Validator header roundtrip keeps class + core method.
|
||||
{
|
||||
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||||
Pipeline pipeline;
|
||||
const std::string generated = pipeline.generate(validator.ast.get(), "cpp");
|
||||
assert(!generated.empty());
|
||||
auto roundtrip = SelfHostHarness::parseSource(generated, "validator_roundtrip");
|
||||
assert(roundtrip.parseSuccess && roundtrip.ast != nullptr);
|
||||
std::cout << "PASS: test 7 — validator parse/generate/parse roundtrip\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 8: Pipeline full run succeeds for conflict header source.
|
||||
{
|
||||
const std::string source = SelfHostHarness::readFile(conflictHeaderPath());
|
||||
Pipeline pipeline;
|
||||
auto result = pipeline.run(source, "cpp", "cpp");
|
||||
assert(result.success);
|
||||
assert(result.ast != nullptr);
|
||||
assert(!result.generatedCode.empty());
|
||||
std::cout << "PASS: test 8 — pipeline.run success for conflict header\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 9: Pipeline full run succeeds for validator header source.
|
||||
{
|
||||
const std::string source = SelfHostHarness::readFile(validatorHeaderPath());
|
||||
Pipeline pipeline;
|
||||
auto result = pipeline.run(source, "cpp", "cpp");
|
||||
assert(result.success);
|
||||
assert(result.ast != nullptr);
|
||||
assert(!result.generatedCode.empty());
|
||||
std::cout << "PASS: test 9 — pipeline.run success for validator header\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 10: Semanno emit/parse works with inferred complexity annotation.
|
||||
{
|
||||
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||||
AnnotationInference inf;
|
||||
auto inferred = inf.inferAll(validator.ast.get());
|
||||
|
||||
std::string complexityValue = "O(1)";
|
||||
for (const auto& item : inferred) {
|
||||
if (item.annotationType == "ComplexityAnnotation") {
|
||||
complexityValue = item.value;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ComplexityAnnotation anno;
|
||||
anno.timeComplexity = complexityValue;
|
||||
anno.cognitiveComplexity = 3;
|
||||
anno.linesOfLogic = 10;
|
||||
|
||||
const std::string semanno = SemannoEmitter::emit(&anno);
|
||||
assert(SemannoParser::isSemannoComment(semanno));
|
||||
auto parsed = SemannoParser::parse(semanno);
|
||||
assert(parsed.type == "complexity");
|
||||
assert(parsed.properties.count("timeComplexity") > 0);
|
||||
assert(parsed.properties["timeComplexity"] == complexityValue);
|
||||
std::cout << "PASS: test 10 — semanno roundtrip for inferred complexity\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 11: Generated output preserves structural signal density.
|
||||
{
|
||||
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||||
Pipeline pipeline;
|
||||
const std::string generated = pipeline.generate(conflict.ast.get(), "cpp");
|
||||
assert(!generated.empty());
|
||||
auto roundtrip = SelfHostHarness::parseSource(generated, "signal_density");
|
||||
assert(roundtrip.parseSuccess && roundtrip.ast != nullptr);
|
||||
std::cout << "PASS: test 11 — structural density preserved after regeneration\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
// Test 12: Combined generated self-host sources parse together.
|
||||
{
|
||||
auto conflict = SelfHostHarness::parseFile(conflictHeaderPath());
|
||||
auto validator = SelfHostHarness::parseFile(validatorHeaderPath());
|
||||
Pipeline pipeline;
|
||||
const std::string generatedConflict = pipeline.generate(conflict.ast.get(), "cpp");
|
||||
const std::string generatedValidator = pipeline.generate(validator.ast.get(), "cpp");
|
||||
const std::string combined = generatedConflict + "\n\n" + generatedValidator;
|
||||
auto merged = SelfHostHarness::parseSource(combined, "combined_self_host");
|
||||
assert(merged.parseSuccess && merged.ast != nullptr);
|
||||
assert(!generatedConflict.empty());
|
||||
assert(!generatedValidator.empty());
|
||||
std::cout << "PASS: test 12 — combined generated self-host parse succeeds\n";
|
||||
passed++;
|
||||
}
|
||||
|
||||
std::cout << "\nStep 403 result: " << passed << "/12 tests passed\n";
|
||||
return (passed == 12) ? 0 : 1;
|
||||
}
|
||||
Reference in New Issue
Block a user