-2⁻¹⁴⁹ tot (2 - 2⁻²³) * 2¹²⁷

-2⁻¹⁰⁷⁴ tot (2 - 2⁻⁵²) * 2¹⁰²³

package com.example;
import com.github.javaparser.StaticJavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.VariableDeclarator;
import org.junit.jupiter.api.*;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.PrintStream;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.*;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;

public class MainTest {
    private static CompilationUnit cu;

    @BeforeAll
    public static void setup() throws Exception {
        // Поднимаемся от target/test-classes до корня проекта
        File projectRoot = new File(
            MainTest.class.getProtectionDomain().getCodeSource().getLocation().toURI()
        ).getParentFile().getParentFile();

        File file = new File(projectRoot, "src/main/java/com/example/Main.java");
        cu = StaticJavaParser.parse(file);
    }

    private String getVariableType(String varName) {
        return cu.findAll(VariableDeclarator.class).stream()
                .filter(v -> v.getNameAsString().equals(varName))
                .findFirst()
                .map(VariableDeclarator::getTypeAsString)
                .orElse(null);
    }

    record VarCheck(String name, List<String> allowedTypes) {}

    @TestFactory
    Stream<DynamicTest> dynamicTypeTests() {
        List<VarCheck> checks = List.of(
                new VarCheck("myNum",        List.of("byte", "short", "int", "long")),
                new VarCheck("myFractional", List.of("double")),
                new VarCheck("myBiggerNum",  List.of("byte", "short", "int", "long")),
                new VarCheck("myLetter",     List.of("char")),
                new VarCheck("myBool",       List.of("boolean")),
                new VarCheck("myWho",        List.of("float"))
        );

        return checks.stream().map(check -> {
            String actualType = getVariableType(check.name());
            boolean valid = actualType != null && check.allowedTypes().contains(actualType);
            String displayName = valid
                    ? check.name() + " variable has valid type (" + String.join("/", check.allowedTypes()) + ")"
                    : "Expected " + check.name() + " variable to have type: " + String.join("/", check.allowedTypes());
            return dynamicTest(displayName, () -> {
                assertNotNull(actualType, "Variable '" + check.name() + "' not found");
                assertTrue(check.allowedTypes().contains(actualType), "Found: " + actualType);
            });
        });
    }

    @Test
    @DisplayName("The code prints the right message")
    void testPrintsHelloWorldFlexible() {
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        PrintStream originalOut = System.out;
        System.setOut(new PrintStream(outContent));
        Main.main(new String[]{});
        System.setOut(originalOut);

        String output = outContent.toString().trim();
        // Исправлено: \\s вместо \\\s
        Pattern pattern = Pattern.compile("It's\\s+working\\s*,\\s*well\\s+done\\s*!?", Pattern.CASE_INSENSITIVE);
        assertTrue(pattern.matcher(output).find(), "Actual output: " + output);
    }
}

MainTest.java

Leer de basisprincipes van Java en de belangrijkste kenmerken in deze cursus. Aan het einde ben je in staat om eenvoudige algoritmische taken op te lossen en krijg je een duidelijk inzicht in hoe basisconsoletoepassingen in Java werken.

Ontdek de unieke kenmerken van Java en begrijp waarom het een aanbevolen programmeertaal is om te leren. Schrijf je eerste Java-code en verken hoe je tekst naar de console kunt printen.

Leer de basisprincipes van programmeren, verdiep je in primitieve gegevenstypen en verken bewerkingen met deze typen. Schrijf code die wiskundige taken uitvoert en voorwaarden evalueert voor een soepele uitvoering.

Ontdek verschillende lussen zoals for, while en do-while, die essentieel zijn in elke programmeertaal. Lussen maken efficiënte iteratie over grote datasets mogelijk, wat aanzienlijk tijd bespaart. Pas ze uitgebreid toe bij taken zoals sorteren, werken met arrays, collecties en meer.

Leer hoe u arrays effectief kunt gebruiken in Java-programmering door te ontdekken hoe u gegevens groepeert in arrays en veelgebruikte methoden en eigenschappen voor het werken ermee te verkennen. Technieken voor het manipuleren en optimaliseren van arrays in praktijktoepassingen zullen ook worden onderzocht.

Leer meer over String, een cruciaal gegevenstype in Java, en ontdek de vele ingebouwde methoden en bewerkingen. Verken String en StringBuilder, waarbij je de basisprincipes van hun methoden begrijpt en leert hoe je strings effectief gebruikt in Java.

Challenge: Primitieve Types

Challenge: Primitieve Types

Oplossing