il2cpp-dump-analyzer-mcp
Version:
Agentic RAG system for analyzing IL2CPP dump.cs files from Unity games
219 lines • 7.82 kB
JavaScript
;
/**
* Real Data Test Helpers
* Utility functions for working with real dump.cs data in tests
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.RealDataValidation = exports.RealDataPerformance = exports.RealDataQueries = exports.RealDataAssertions = void 0;
/**
* Test assertion helpers for real data validation
*/
class RealDataAssertions {
/**
* Assert that a class exists in the real data
*/
static assertClassExists(context, className) {
const foundClass = context.classes.find(cls => cls.name === className || cls.fullName === className);
if (!foundClass) {
const availableClasses = context.classes.slice(0, 10).map(cls => cls.name).join(', ');
throw new Error(`Class '${className}' not found in real dump.cs data. ` +
`Available classes (first 10): ${availableClasses}`);
}
return foundClass;
}
/**
* Assert that an enum exists in the real data
*/
static assertEnumExists(context, enumName) {
const foundEnum = context.enums.find(enm => enm.name === enumName || enm.fullName === enumName);
if (!foundEnum) {
const availableEnums = context.enums.slice(0, 10).map(enm => enm.name).join(', ');
throw new Error(`Enum '${enumName}' not found in real dump.cs data. ` +
`Available enums (first 10): ${availableEnums}`);
}
return foundEnum;
}
/**
* Assert that MonoBehaviours exist in the real data
*/
static assertMonoBehavioursExist(context) {
if (context.monoBehaviours.length === 0) {
throw new Error('No MonoBehaviour classes found in real dump.cs data');
}
return context.monoBehaviours;
}
/**
* Assert that search results contain expected metadata
*/
static assertSearchResultsValid(results, expectedType) {
if (results.length === 0) {
throw new Error('Search results are empty');
}
for (const result of results) {
if (!result.metadata) {
throw new Error('Search result missing metadata');
}
if (!result.metadata.name) {
throw new Error('Search result missing name in metadata');
}
if (!result.metadata.type) {
throw new Error('Search result missing type in metadata');
}
if (expectedType && result.metadata.type !== expectedType) {
throw new Error(`Expected result type '${expectedType}', got '${result.metadata.type}'`);
}
}
}
}
exports.RealDataAssertions = RealDataAssertions;
/**
* Real data query helpers for common test scenarios
*/
class RealDataQueries {
/**
* Get a known MonoBehaviour class name from real data
*/
static getKnownMonoBehaviourName(context) {
if (context.monoBehaviours.length === 0) {
throw new Error('No MonoBehaviour classes found in real data');
}
// Return the first MonoBehaviour found
return context.monoBehaviours[0].name;
}
/**
* Get a known enum name from real data
*/
static getKnownEnumName(context) {
if (context.enums.length === 0) {
throw new Error('No enums found in real data');
}
// Return the first enum found
return context.enums[0].name;
}
/**
* Get a known class name from real data
*/
static getKnownClassName(context) {
if (context.classes.length === 0) {
throw new Error('No classes found in real data');
}
// Return the first class found
return context.classes[0].name;
}
/**
* Get a known namespace from real data
*/
static getKnownNamespace(context) {
const namespaces = [...new Set(context.classes.map(cls => cls.namespace).filter(Boolean))];
if (namespaces.length === 0) {
throw new Error('No namespaces found in real data');
}
return namespaces[0];
}
/**
* Get search queries that should return results based on real data
*/
static getValidSearchQueries(context) {
const queries = [];
// Add class names
if (context.classes.length > 0) {
queries.push(context.classes[0].name);
}
// Add MonoBehaviour names
if (context.monoBehaviours.length > 0) {
queries.push(context.monoBehaviours[0].name);
}
// Add enum names
if (context.enums.length > 0) {
queries.push(context.enums[0].name);
}
// Add common Unity terms that should exist in real data
queries.push('MonoBehaviour', 'GameObject', 'Component');
return queries;
}
/**
* Get search queries that should return no results
*/
static getInvalidSearchQueries() {
return [
'NonExistentClass123',
'FakeMonoBehaviour456',
'InvalidEnum789',
'ThisClassDoesNotExist'
];
}
}
exports.RealDataQueries = RealDataQueries;
/**
* Performance test helpers for real data
*/
class RealDataPerformance {
/**
* Measure search performance with real data
*/
static async measureSearchPerformance(vectorStore, query, iterations = 10) {
const times = [];
for (let i = 0; i < iterations; i++) {
const startTime = Date.now();
await vectorStore.similaritySearch(query, 5);
const endTime = Date.now();
times.push(endTime - startTime);
}
return {
averageTime: times.reduce((sum, time) => sum + time, 0) / times.length,
minTime: Math.min(...times),
maxTime: Math.max(...times)
};
}
/**
* Validate that search performance meets expectations
*/
static assertSearchPerformance(performanceResult, maxAverageTime = 1000) {
if (performanceResult.averageTime > maxAverageTime) {
throw new Error(`Search performance too slow: ${performanceResult.averageTime}ms average ` +
`(expected < ${maxAverageTime}ms)`);
}
}
}
exports.RealDataPerformance = RealDataPerformance;
/**
* Real data validation helpers
*/
class RealDataValidation {
/**
* Validate that the real data context is properly set up
*/
static validateTestContext(context) {
if (!context.vectorStore) {
throw new Error('Vector store not initialized in test context');
}
if (!context.parser) {
throw new Error('Parser not initialized in test context');
}
if (!context.documents || context.documents.length === 0) {
throw new Error('No documents found in test context');
}
if (!context.classes || context.classes.length === 0) {
throw new Error('No classes found in test context');
}
}
/**
* Validate that real data contains expected Unity patterns
*/
static validateUnityPatterns(context) {
// Check for MonoBehaviour classes
if (context.monoBehaviours.length === 0) {
console.warn('Warning: No MonoBehaviour classes found in real data');
}
// Check for Unity-specific patterns
const hasUnityPatterns = context.classes.some(cls => cls.baseClass === 'MonoBehaviour' ||
cls.baseClass === 'ScriptableObject' ||
cls.name.includes('Unity') ||
cls.namespace?.includes('Unity'));
if (!hasUnityPatterns) {
console.warn('Warning: No Unity-specific patterns found in real data');
}
}
}
exports.RealDataValidation = RealDataValidation;
//# sourceMappingURL=real-data-helpers.js.map