{
  "assessmentTests": {
    "java_test": {
      "name": "Tes Java",
      "desc": "30 pitakon skenario babagan sintaksis inti, mekanisme OOP, koleksi, generik, eksepsi, lan konkurensi — pirsani menawi Java panjenengan cocog kaliyan ingkang dipunmaksud lowongan pakaryan kanthi kaprigelan Java.",
      "recommendation": "Profil kaprigelan Java panjenengan",
      "results": {
        "beginner": {
          "name": "Pemula",
          "desc": "Panjenengan saged nulis kelas lan metode ingkang makarya, nanging pitakon ingkang panjenengan wangsuli klèru punika nglumpuk ing bab identitas lan nilai standar, sanes sintaksis — String == vs .equals, kenging punapa new String(“x”) boten nate migunakaken malih string pool, nilai standar field numerik dibandhingaken kaliyan field wrapper. Sedaya punika sanes tandha bilih panjenengan awon ing Java; punika aturan-aturan khusus ingkang njalari tiyang kesandhung, inggih punika tiyang ingkang sinau basa punika kanthi nyoba lan klèru, sanes saking pangertosan carane referensi lan primitif sejatosipun makarya ing sajeroning sistem. Punika wigati ing pagawean amargi saben satunggalipun punika papan ingkang kode saged dipunkompilasi, mlaku, lan meneng-meneng nindakaken bab ingkang klèru.",
          "recommendation": "Mangga wiwiti saking tiga bab, kanthi urutan punika: kenging punapa == ing kalih objek String mbandhingaken referensi, sanes aksara (lan .equals punika ingkang meh tansah panjenengan betahaken), kados pundi luberipun int muter kanthi meneng tinimbang mbuwang eksepsi, lan kenging punapa field Integer ingkang dereng dipuninisialisasi nilai standaripun null dene field int nilai standaripun 0. Pandhuan Java resmi saking Oracle lan Baeldung kalih-kalihipun mbahas katiga bab punika kanthi conto ingkang saged dipunjalanaken."
        },
        "intermediate": {
          "name": "Menengah",
          "desc": "Panjenengan saged nangani kode aplikasi saben dina kanthi lancar — kelas, koleksi, alur kontrol sing prasaja — lan mboten bakal kaganggu ing pagawéan fitur rutin. Bédané antarane tingkat punika lan Lanjut utamané ana ing apa sing kelakon nalika aturan Java ketemu karo concurrency lan generics: metode static sing dipilih miturut tipe sing dideklarasiaké, dudu objek sing panjenengan kinten, urutan iterasi HashMap sing panjenengan andelaké tanpa sadhar, utawa ConcurrentModificationException saka mbusak item ing tengah loop. Bug-bug kaya mengkono gampang kliwatan nalika diwaca sepisan, lan mung katon ing kondisi runtime tartamtu.",
          "recommendation": "Mangga fokus marang bédané pandelengan statis compiler marang kode panjenengan lan apa sing bener-bener mlaku: resolusi overload lan static-method hiding miturut tipe sing dideklarasiaké, dudu tipe runtime, yagene HashMap ora njamin urutan iterasi, lan yagene ngowahi list langsung nalika iterasi mbuwang ConcurrentModificationException. Sawisé iku generics erasure, amarga bab iki asring ndadèkaké kesandhung wong sing wis ngerti koleksi siji-siji."
        },
        "advanced": {
          "name": "Lanjutan",
          "desc": "Punika tingkat sing dimaksud ing sapérangan gedhé lowongan pagawéan nalika nyebut “Java sing kuwat.” Panjenengan maca kelas kanthi static block, instance block lan pirang-pirang constructor lan saged ngramalaké urutan pasti anggoné mlaku, panjenengan ngerti yagene blok finally saged nibakaké nilai return saka blok try kanthi meneng-meneng, lan panjenengan milih try-with-resources tinimbang finally-close manual amarga panjenengan ngerti jaminan urutan sing diparingaké. Sing misahaké tingkatan punika saka tingkat paling dhuwur yaiku sisi concurrent lan tingkat interface ing pagawéan: apa sing bener-bener dikunci synchronized, apa sing dijamin lan ora dijamin volatile, lan kepriye konflik default-method dirampungaké.",
          "recommendation": "Mangga sinau luwih jero babagan bagéan-bagéan sing nglindhungi kode sing uga disenggol thread lan interface liyané: bédané apa sing dikunci synchronized instance method dibandhingaké synchronized static method, yagene volatile maringi visibilitas nanging dudu atomisitas kanggo counter++, lan kepriye Java meksa panjenengan ngrampungaké default-method diamond kanthi manual. Materi Baeldung lan Java Concurrency in Practice babagan Java Memory Model dadi pandhapuk sabanjuré sing cocog kanggo kekalihipun."
        },
        "expert": {
          "name": "Ahli",
          "desc": "Skor panjenengan paling dhuwur ing saben bagéan — sintaks lan tipe inti, mekanika OOP lan scope, koleksi lan generics, lan exception, concurrency lan idiom. Kanthi praktis, tegesé panjenengan saged nampa kelas gawéané wong liya lan njlentrehaké yagene kesalahan compile, exception runtime, utawa nilai sing salah kanthi meneng-meneng kedadéan, mboten mung apa sing dikandhakaké sintaks, yaiku kaprigelan sing luwih angel lan luwih aji. Ing tingkat punika basa kasebut piyambak arang dadi faktor sing mbatesi; watesé biasané desain concurrency utawa wujud data ing ngisoré.",
          "recommendation": "Kauntungan paling gedhé saiki ana ing desain lan diagnosis: maca thread dump sadurungé nganggep hang punika deadlock, milih antarane synchronized, lock java.util.concurrent lan atomic minangka pertimbangan, dudu pilihan baku, lan desain stream-pipeline sing tetep lazy kanthi sengaja, dudu amarga kebeneran. Yèn panjenengan lagi disaring kanggo sawijining peran, jlentrehna bug concurrency kaya happens-before edge sing kaliwatan utawa ConcurrentModificationException sing panjenengan temokaké ing production, tinimbang namakaké fitur Java — punika nuduhaké nalar, mboten mung kosakata."
        }
      },
      "questions": [
        {
          "question": "Panjenengan nggawe rong objek String: String a = new String(“cat”); String b = new String(“cat”); Apa asilé evaluasi a == b?",
          "options": [
            {
              "icon": "",
              "label": "true"
            },
            {
              "icon": "",
              "label": "Gumantung marang setelan string-pool JVM"
            },
            {
              "icon": "",
              "label": "Kesalahan compile"
            },
            {
              "icon": "",
              "label": "false"
            }
          ]
        },
        {
          "question": "Integer x = 100; Integer y = 100; System.out.println(x == y); banjur Integer x2 = 200; Integer y2 = 200; System.out.println(x2 == y2); Apa sing dicithak dening rong baris kasebut?",
          "options": [
            {
              "icon": "",
              "label": "true banjur true"
            },
            {
              "icon": "",
              "label": "false banjur false"
            },
            {
              "icon": "",
              "label": "Ora bisa dikompilasi"
            },
            {
              "icon": "",
              "label": "true banjur false"
            }
          ]
        },
        {
          "question": "int max = Integer.MAX_VALUE; System.out.println(max + 1); Apa sing kelakon?",
          "options": [
            {
              "icon": "",
              "label": "Mbuwang ArithmeticException"
            },
            {
              "icon": "",
              "label": "Nyithak Integer.MAX_VALUE maneh"
            },
            {
              "icon": "",
              "label": "Nyithak Integer.MIN_VALUE"
            },
            {
              "icon": "",
              "label": "Kesalahan compile"
            }
          ]
        },
        {
          "question": "System.out.println(0.1 + 0.2 == 0.3); Apa sing dicithak, lan yagene?",
          "options": [
            {
              "icon": "",
              "label": "false, amarga 0.1 lan 0.2 ora persis ing floating point binar"
            },
            {
              "icon": "",
              "label": "true, amarga Java mbunderaké jumlah double menyang desimal paling cedhak"
            },
            {
              "icon": "",
              "label": "true, amarga nilai rong desimal bisa ditambah persis ing double"
            },
            {
              "icon": "",
              "label": "Mbuwang ArithmeticException kanggo pambandhingan sing ora persis"
            }
          ]
        },
        {
          "question": "Sawijining kelas ndeklarasiaké rong instance field tanpa initializer: int count; lan Integer total; Sadurungé constructor mlaku, apa nilai awalé?",
          "options": [
            {
              "icon": "",
              "label": "Loro-lorone 0"
            },
            {
              "icon": "",
              "label": "Ora ana sing nduwèni nilai nganti diisi"
            },
            {
              "icon": "",
              "label": "count yaiku 0 lan total yaiku null"
            },
            {
              "icon": "",
              "label": "Loro-lorone null"
            }
          ]
        },
        {
          "question": "Sawijining loop mlaku 1000 kaping, saben-saben nindakaké result += “x”; ing result String. Apa sing bener-bener kelakon ing mburi layar saben iterasi?",
          "options": [
            {
              "icon": "",
              "label": "Array karakter String sing wis ana dipanjangaké ing panggonan"
            },
            {
              "icon": "",
              "label": "Java nglumpukaké kabèh gabungan teks dadi siji String pungkasan"
            },
            {
              "icon": "",
              "label": "Siji StringBuilder dienggo bebarengan ing kabèh 1000 iterasi"
            },
            {
              "icon": "",
              "label": "String anyar digawé lan dilebokaké ing result"
            }
          ]
        },
        {
          "question": "final List<String> names = new ArrayList<>(); Endi saka pernyataan iki sing bener?",
          "options": [
            {
              "icon": "",
              "label": "names.add(“Ana”) bisa dikompilasi lan mlaku"
            },
            {
              "icon": "",
              "label": "names.add(“Ana”) ora bisa dikompilasi"
            },
            {
              "icon": "",
              "label": "List aman kanggo nulis bebarengan"
            },
            {
              "icon": "",
              "label": "final ora ana pengaruhé marang variabel lokal"
            }
          ]
        },
        {
          "question": "int[] a = {1, 2, 3}; int[] b = {1, 2, 3}; System.out.println(a == b); System.out.println(Arrays.equals(a, b)); Apa sing dicithak dening rong baris kasebut?",
          "options": [
            {
              "icon": "",
              "label": "false banjur true"
            },
            {
              "icon": "",
              "label": "true banjur true"
            },
            {
              "icon": "",
              "label": "false banjur false"
            },
            {
              "icon": "",
              "label": "Ora bisa dikompilasi"
            }
          ]
        },
        {
          "question": "void show(Object o) { print(“Object”); } void show(String s) { print(“String”); } Object ref = “hello”; show(ref); Overload endi sing mlaku, lan yagene?",
          "options": [
            {
              "icon": "",
              "label": "show(String), amarga kelas runtime objek iku String"
            },
            {
              "icon": "",
              "label": "show(Object), amarga overload dipilih saka tipe sing dideklarasiaké"
            },
            {
              "icon": "",
              "label": "Ora siji-sijia; panggilan iku ambigu lan ora bisa dikompilasi"
            },
            {
              "icon": "",
              "label": "Loro-lorone mlaku, saben sepisan, amarga saben overload cocog"
            }
          ]
        },
        {
          "question": "Kelas Base ndeklarasiaké static void greet() { print(“Base”); }. Kelas Derived extends Base lan uga ndeklarasiaké static void greet() { print(“Derived”); }. Panjenengan nulis: Base ref = new Derived(); ref.greet(); Apa sing dicithak?",
          "options": [
            {
              "icon": "",
              "label": "Derived"
            },
            {
              "icon": "",
              "label": "Ora bisa dikompilasi"
            },
            {
              "icon": "",
              "label": "Dhasar"
            },
            {
              "icon": "",
              "label": "Base, banjur Derived"
            }
          ]
        },
        {
          "question": "Ing njero metode, panjenengan nulis int count = 0; banjur nyoba ngrujuk count saka njero lambda sing diparingaké marang metode liya. Apa sing kedah bener bab count supados kode kasebut saged dikompilasi?",
          "options": [
            {
              "icon": "",
              "label": "Kudu final utawa effectively final"
            },
            {
              "icon": "",
              "label": "Ora ana; variabel lokal apa wae bisa"
            },
            {
              "icon": "",
              "label": "Kudu dideklarasiaké volatile"
            },
            {
              "icon": "",
              "label": "Kudu dadi field, dudu variabel lokal"
            }
          ]
        },
        {
          "question": "void rename(StringBuilder sb) { sb = new StringBuilder(“new”); } dipanggil kaya StringBuilder original = new StringBuilder(“old”); rename(original); Original dadi apa sawisé panggilan?",
          "options": [
            {
              "icon": "",
              "label": "Yaiku “new”"
            },
            {
              "icon": "",
              "label": "Nilainé null"
            },
            {
              "icon": "",
              "label": "Isih “old”"
            },
            {
              "icon": "",
              "label": "Runtime exception dilempar"
            }
          ]
        },
        {
          "question": "Sawijining class nduwèni static initializer block, instance initializer block, lan constructor, kanthi urutan kasebut ing source code. Panjenengan damel kalih objek saka class punika, siji sawisé siji. Kabèh punika mlaku kanthi urutan kepriyé?",
          "options": [
            {
              "icon": "",
              "label": "Static block sepisan; banjur, saben objek, instance block banjur constructor"
            },
            {
              "icon": "",
              "label": "Telu-telune mlaku, miturut urutan ing source code, kanggo saben objek"
            },
            {
              "icon": "",
              "label": "Saben objek, constructor banjur instance block; static block sepisan ing pungkasan"
            },
            {
              "icon": "",
              "label": "Static block sepisan saben objek, banjur instance block, banjur constructor"
            }
          ]
        },
        {
          "question": "Sawijining class nduwèni void log(String s) lan void log(String... args). Panjenengan nyeluk log(“hi”). Endi sing mlaku?",
          "options": [
            {
              "icon": "",
              "label": "log(String... args)"
            },
            {
              "icon": "",
              "label": "Compile error: panyeluké ambigu"
            },
            {
              "icon": "",
              "label": "log(String s)"
            },
            {
              "icon": "",
              "label": "Overload endi wae sing dideklarasi dhisik"
            }
          ]
        },
        {
          "question": "Baris kapisan sawijining constructor nyeluk this(0); kanggo ndelegasi menyang constructor liyane ing class sing padha. Ing ngendi panggonané sing diidinaké?",
          "options": [
            {
              "icon": "",
              "label": "Ing ngendi wae ing body, sadurungé constructor rampung"
            },
            {
              "icon": "",
              "label": "Mung minangka statement kapisan ing constructor"
            },
            {
              "icon": "",
              "label": "Mung minangka statement pungkasan ing constructor"
            },
            {
              "icon": "",
              "label": "Mung ing constructor sing ditandhani nganggo keyword delegate"
            }
          ]
        },
        {
          "question": "Panjenengan peryogi list sing bakal kerep banget disisipi elemen ing ngarep, déné maca kanthi random-access arang kalakon. Endi sing luwih cocog saka sisi struktur, lan apa sababé?",
          "options": [
            {
              "icon": "",
              "label": "ArrayList, amarga array dhasaré ndadèkaké nyisipaké ing ngarep paling cepet"
            },
            {
              "icon": "",
              "label": "Sing endi wae, amarga loro-lorone ngimplementasi List kanthi jaminan sing padha"
            },
            {
              "icon": "",
              "label": "LinkedList, amarga nyisipaké ing ngarep iku O(1), dudu O(n)"
            },
            {
              "icon": "",
              "label": "LinkedList, amarga nyadhiyakaké random access O(1)"
            }
          ]
        },
        {
          "question": "Panjenengan nyisipaké gangsal entri menyang HashMap biasa kanthi urutan tartamtu, banjur nelusuri isiné nganggo for-each loop. Entri-entri kasebut metu kanthi urutan kepriyé?",
          "options": [
            {
              "icon": "",
              "label": "Urutan panyisipan"
            },
            {
              "icon": "",
              "label": "Ora ana urutan sing dijamin"
            },
            {
              "icon": "",
              "label": "Diurutaké miturut key"
            },
            {
              "icon": "",
              "label": "Urutan panyisipan kosok balèn"
            }
          ]
        },
        {
          "question": "Pira key null sing bisa ditampung java.util.HashMap biasa ing wektu sing padha, lan pira nilai null?",
          "options": [
            {
              "icon": "",
              "label": "Ora ana key null lan ora ana nilai null"
            },
            {
              "icon": "",
              "label": "Siji key null, nilai null pira wae"
            },
            {
              "icon": "",
              "label": "Key utawa nilai null pira wae"
            },
            {
              "icon": "",
              "label": "Siji key null lan siji nilai null"
            }
          ]
        },
        {
          "question": "Panjenengan nelusuri List nganggo for-each loop lan nyeluk list.remove(item) langsung ing list saka njero isi loop, kanggo sawetara elemen nanging ora kabèh. Apa sing kelakon?",
          "options": [
            {
              "icon": "",
              "label": "Mbusak elemen-elemen sing dikarepaké kanthi pas"
            },
            {
              "icon": "",
              "label": "Mbusak elemen-elemen kasebut, nanging mung sawisé loop rampung"
            },
            {
              "icon": "",
              "label": "Nglempar IndexOutOfBoundsException"
            },
            {
              "icon": "",
              "label": "Nglempar ConcurrentModificationException"
            }
          ]
        },
        {
          "question": "Nalika runtime, saka List<String> list, apa sing sejatiné bisa panjenengan weruhi babagan parameter tipe generiké liwat reflection utawa instanceof?",
          "options": [
            {
              "icon": "",
              "label": "list.getElementType() ngasilaké String.class"
            },
            {
              "icon": "",
              "label": "instanceof List<String> mriksa tipe elemen"
            },
            {
              "icon": "",
              "label": "JVM nyimpen tipe kasebut minangka metadata sing bisa diwaca liwat getGenericType()"
            },
            {
              "icon": "",
              "label": "Ora ana apa-apa babagan tipe elemen"
            }
          ]
        },
        {
          "question": "switch (day) { case 1: case 2: print(“Dina Kerja”); break; case 6: print(“Setu”); case 7: print(“Minggu”); break; default: print(“?”); } Yèn day yaiku 6, apa sing dicithak?",
          "options": [
            {
              "icon": "",
              "label": "Mung Setu"
            },
            {
              "icon": "",
              "label": "Mung Minggu"
            },
            {
              "icon": "",
              "label": "Setu, Minggu, banjur ?"
            },
            {
              "icon": "",
              "label": "Setu, banjur Minggu"
            }
          ]
        },
        {
          "question": "Class Product mbutuhaké sawijining urutan “alami” sing jelas miturut rega, ditambah kamampuan uga ngurutaké miturut jeneng utawa miturut tingkat stok ing panggonan sing beda-beda ing codebase. Kombinasi endi sing dadi desain sing pas?",
          "options": [
            {
              "icon": "",
              "label": "Ngimplementasi Comparable<Product> kaping telu kanthi kapisah"
            },
            {
              "icon": "",
              "label": "Comparable kanggo rega, ditambah Comparator kapisah kanggo jeneng lan stok"
            },
            {
              "icon": "",
              "label": "Comparable kanggo jeneng, ditambah Comparator kanggo rega lan stok"
            },
            {
              "icon": "",
              "label": "Siji Comparable kanthi telung method compareTo sing dioverload"
            }
          ]
        },
        {
          "question": "Sawijining method nyeluk new FileReader(path), sing ndeklarasi throws IOException. IOException nurun saka Exception, dudu saka RuntimeException. Apa sing kudu panjenengan tindakaké supaya punika bisa dikompilasi?",
          "options": [
            {
              "icon": "",
              "label": "Ora perlu apa-apa; bisa dikompilasi kaya sing ditulis"
            },
            {
              "icon": "",
              "label": "Nangkep IOException utawa ndeklarasi throws IOException"
            },
            {
              "icon": "",
              "label": "Nangkep RuntimeException ing sakubengé panyeluk"
            },
            {
              "icon": "",
              "label": "Ndeklarasi method dadi static"
            }
          ]
        },
        {
          "question": "try (Resource a = new Resource(“A”); Resource b = new Resource(“B”)) { ... } nganggo rong resource sing ngimplementasi AutoCloseable. Yèn blok try rampung kanthi normal, resource-resource kasebut ditutup kanthi urutan kepriyé?",
          "options": [
            {
              "icon": "",
              "label": "Miturut urutan deklarasi, A banjur B"
            },
            {
              "icon": "",
              "label": "B dhisik, banjur A"
            },
            {
              "icon": "",
              "label": "Loro-lorone ing wektu sing padha"
            },
            {
              "icon": "",
              "label": "Mung B sing ditutup kanthi otomatis"
            }
          ]
        },
        {
          "question": "int getValue() { try { return 1; } finally { return 2; } } Apa sing dibalèkaké nalika nyeluk getValue()?",
          "options": [
            {
              "icon": "",
              "label": "1"
            },
            {
              "icon": "",
              "label": "Nglempar exception"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "Ora bisa dikompilasi"
            }
          ]
        },
        {
          "question": "try { ... } catch (IOException e) { ... } catch (FileNotFoundException e) { ... }, lan FileNotFoundException nurun saka IOException. Apa sing kelakon nalika panjenengan nyoba ngompilasi kode kasebut?",
          "options": [
            {
              "icon": "",
              "label": "Compile error amarga catch kapindho ora bisa dijangkau"
            },
            {
              "icon": "",
              "label": "Bisa dikompilasi; blok FileNotFoundException nangani tipe kasebut"
            },
            {
              "icon": "",
              "label": "Bisa dikompilasi, lan loro-lorone blok catch mlaku kanthi urutan"
            },
            {
              "icon": "",
              "label": "Bisa dikompilasi nanging gagal nalika runtime ing FileNotFoundException"
            }
          ]
        },
        {
          "question": "Sawijining class nduwèni method instance synchronized process() lan method static synchronized configure(). Apa, kanthi spesifik, sing dikunci saben method?",
          "options": [
            {
              "icon": "",
              "label": "process() ngunci instance; configure() ngunci objek Class"
            },
            {
              "icon": "",
              "label": "Loro-lorone ngunci siji lock global kanggo sakabèhing JVM"
            },
            {
              "icon": "",
              "label": "process() ngunci objek Class; configure() ngunci instance sing nyeluk"
            },
            {
              "icon": "",
              "label": "Ora ana sing ngunci apa-apa yèn ora ana blok synchronized ing njerone"
            }
          ]
        },
        {
          "question": "Sawijining field dideklarasi volatile int counter = 0;, lan pirang-pirang thread nglakokaké counter++ ing field kasebut bebarengan. Apa volatile bisa nyegah update sing ilang ing kéné?",
          "options": [
            {
              "icon": "",
              "label": "Inggih"
            },
            {
              "icon": "",
              "label": "No"
            },
            {
              "icon": "",
              "label": "Mung kanggo field int lan long"
            },
            {
              "icon": "",
              "label": "Mung yèn field kasebut uga static"
            }
          ]
        },
        {
          "question": "Interface A lan interface B padha-padha ndeklarasi default method describe(). Sawijining class ngimplementasi A lan B lan ora ngoverride describe() dhewe. Apa sing kelakon?",
          "options": [
            {
              "icon": "",
              "label": "Versi A sing mlaku, amarga A ditulis dhisik"
            },
            {
              "icon": "",
              "label": "Loro-lorone versi mlaku, siji sawisé siji"
            },
            {
              "icon": "",
              "label": "Bisa dikompilasi nanging nglempar exception nalika dipanggil"
            },
            {
              "icon": "",
              "label": "Compile error kajaba class ngoverride describe()"
            }
          ]
        },
        {
          "question": "list.stream().filter(x -> x > 0).map(x -> x * 2); ditulis nanging asilé ora tau diterusaké menyang operasi terminal kaya .collect() utawa .forEach(). Apa sing sejatiné kelakon nalika baris punika dieksekusi?",
          "options": [
            {
              "icon": "",
              "label": "Ora ana apa-apa; pipeline ora tau mlaku"
            },
            {
              "icon": "",
              "label": "Saben elemen langsung difilter lan dimap"
            },
            {
              "icon": "",
              "label": "Mung filter sing mlaku; map ngenteni operasi terminal"
            },
            {
              "icon": "",
              "label": "Nglempar IllegalStateException"
            }
          ]
        }
      ],
      "optionOrderVersion": "9d7b97ef6cccf4e2"
    }
  },
  "testNames": {
    "java-test": "Tes Java"
  }
}