An educational testing and validation framework for programming questions, primarily written in Kotlin with TypeScript components.

Questioner provides a comprehensive framework for creating, validating, and testing programming questions used in educational contexts. It supports both Java and Kotlin programming languages and includes tools for automated testing, mutation testing, and question validation.

This is a multi-module project with the following components:

• lib/: Core library containing question validation logic

  • Main classes: Question, TestQuestion, Validator, TestResults
  • Uses Jeed for Java/Kotlin code execution

• plugin/: Gradle plugin for question management

  • Contains ANTLR grammars for Java/Kotlin parsing
  • Tasks: CollectQuestions, GenerateQuestionTests, PublishQuestions

• server/: REST API server with MongoDB integration

  • Dockerized deployment ready
  • Handles question submission and validation

• stumperd/: Mutation testing and deduplication system

  • Separate Docker setup for advanced testing scenarios

• js/types: Shared TypeScript type definitions
• js/output: Output formatting utilities
• js/mongodb: Database integration utilities

The JavaScript/TypeScript components use NPM workspaces for dependency management.

• Java 21 or later
• Node.js 18 or later
• NPM (for TypeScript components)
• Docker (optional, for server components)

Kotlin/Java components:

./gradlew build        # Build entire project
./gradlew test         # Run all tests
./gradlew clean        # Clean build artifacts

TypeScript/JavaScript components:

cd js
npm install           # Install all workspace dependencies
npm run build         # Build TypeScript packages
npm run check         # Run linting, type checking, and build

Kotlin/Java:

./gradlew dependencies # Show dependency tree
./gradlew test --tests "TestClassName.testMethodName"  # Run specific test

TypeScript/JavaScript:

cd js
npm run prettier      # Format code
npm run eslint        # Lint code
npm run tsc           # Type check without emitting

1. Parsing: Questions are parsed using ANTLR grammars for Java/Kotlin
2. Validation: Core validation logic ensures questions meet educational standards
3. Testing: Automated testing verifies question correctness
4. Mutation Testing: Advanced testing through code mutation (stumperd)

• Languages: Kotlin, Java, TypeScript
• Build System: Gradle (Kotlin/Java), NPM (TypeScript)
• Testing: Kotest (Kotlin), Jest-compatible testing (TypeScript)
• Databases: MongoDB (server component)
• Deployment: Docker containers
• Code Quality: ESLint, Prettier, Kotlinter

This project uses date-based versioning following the pattern YYYY.M.minor (e.g., 2025.7.1).

• Kotlin code follows Kotlinter standards
• TypeScript code uses ESLint 9 with flat config format
• All code is formatted using respective formatters (Kotlinter, Prettier)

• Kotlin tests use Kotest framework
• TypeScript components include comprehensive linting and type checking
• Integration tests validate the complete question pipeline

Server and stumperd components include Docker configurations for containerized deployment:

# Server component
cd server
docker build -t questioner-server .

# Stumperd component  
cd stumperd
docker-compose up

1. Follow existing code style and patterns
2. Ensure all tests pass before submitting changes
3. Update documentation as needed
4. Use the provided linting and formatting tools

See the LICENSE file for license information.