{
  "assessmentTests": {
    "java_test": {
      "name": "جاوا ٹیسٹ",
      "desc": "کور سنٹیکس، آبجیکٹ اورینٹڈ پروگرامنگ کے اصول، کلیکشنز، جنرکس، مستثنیات اور بیک وقت پروگرامنگ پر 30 منظرنامے کے سوالات — معلوم کریں کہ آپ کی جاوا کی مہارت نوکری کی تلاش میں جاوا سے کی گئی ضروریات کے ساتھ کتنی مطابقت رکھتی ہے۔",
      "recommendation": "آپ کے جاوا کی مہارتوں کی پروفائل",
      "results": {
        "beginner": {
          "name": "ابتدائی",
          "desc": "آپ کام کرنے والی کلاسز اور میتھڈز لکھ سکتے ہیں، لیکن جو سوالات آپ نے غلط کیے ہیں وہ سنٹیکس سے زیادہ شناخت اور ڈیفالٹ ویلیوز کے گرد محور ہیں — String == بمقابلہ .equals، کیوں new String(\"x\") کبھی string pool کو دوبارہ استعمال نہیں کرتا، عددی فیلڈ primitive field بمقابلہ wrapper field میں کیا ڈیفالٹ ہوتا ہے۔ یہ سب جاوا میں برا ہونے کے بارے میں نہیں ہے؛ یہ خاص اصول ہیں جو ان لوگوں کو الجھاتے ہیں جنہوں نے زبان آزمائش و خرابی سے سیکھی ہے نہ کہ اس سے کہ references اور primitives در حقیقت کیسے کام کرتے ہیں۔ یہ کام میں اہم ہیں کیونکہ ہر ایک وہ جگہ ہے جہاں کوڈ compile ہوتا ہے، چلتا ہے، اور خاموشی سے غلط کام کرتا ہے۔",
          "recommendation": "تین چیزوں سے شروع کریں، اسی ترتیب میں: کیوں == دو String objects پر references کا موازنہ کرتا ہے، نہ کہ characters کا (اور .equals وہ ہے جو آپ تقریباً ہمیشہ چاہتے ہیں)، کیسے int overflow خاموشی سے wrap کرتی ہے exception پھینکنے کی بجائے، اور کیوں ایک uninitialize شدہ Integer field null کو default کرتا ہے جبکہ int field 0 کو default کرتا ہے۔ Oracle کی سرکاری Java tutorials اور Baeldung دونوں یہ تینوں چیزیں runnable examples کے ساتھ کور کرتے ہیں۔"
        },
        "intermediate": {
          "name": "درمیانی",
          "desc": "آپ روزمرہ کے ایپلیکیشن کوڈ کے ساتھ آرام سے کام کرتے ہیں — کلاسز، collections، سادہ control flow — اور معمول کے feature کام سے سست نہیں ہوں گے۔ یہاں اور Advanced کے درمیان فرق بیشتر اس میں ہے کہ جاوا کے اصول concurrency اور generics کے ساتھ کیسے interact کرتے ہیں: ایک static method جو declared type سے resolve ہوتا ہے آپ کی توقع کے بجائے، HashMap iteration order جس پر آپ خاموشی سے منحصر تھے، ایک ConcurrentModificationException loop کے دوران item کو ہٹانے سے۔ یہ اس قسم کی خرابیاں ہیں جو جلدی پڑھنے سے نکل جاتی ہیں اور صرف مخصوص runtime condition میں نمودار ہوتی ہیں۔",
          "recommendation": "اس پر توجہ دیں کہ آپ کے کوڈ کے compiler کا static view چلنے والی چیز سے کیسے مختلف ہے: overload resolution اور static-method hiding declared type سے runtime type کے بجائے، کیوں HashMap کوئی iteration-order guarantee نہیں دیتا، اور کیوں iteration کے دوران list کو براہ راست modify کرنا ConcurrentModificationException پھینکتا ہے۔ پھر generics erasure، کیونکہ یہ ان لوگوں کو الجھاتا ہے جو پہلے سے collections کو انفرادی طور پر جانتے ہیں۔"
        },
        "advanced": {
          "name": "اعلیٰ",
          "desc": "یہ وہ سطح ہے جو زیادہ تر نوکری کی تلاش میں \"مضبوط جاوا\" سے مراد ہے۔ آپ static blocks، instance blocks اور متعدد constructors والی کلاس پڑھتے ہیں اور یقینی طور سے کہہ سکتے ہیں کہ وہ کس ترتیب میں چلتے ہیں، آپ جانتے ہیں کہ کیوں ایک finally block خاموشی سے try block کی return value کو ختم کر سکتا ہے، اور آپ manual finally-close کی بجائے try-with-resources استعمال کرتے ہیں کیونکہ آپ اس ordering guarantee کو جانتے ہیں جو یہ دیتا ہے۔ یہ band کو top سے علیحدہ کرتا ہے کام کا concurrent اور interface-level پہلو: synchronized اصل میں کیا lock کرتا ہے، volatile کیا guarantee کرتا ہے اور کیا نہیں، اور default-method conflicts کیسے حل ہوتے ہیں۔",
          "recommendation": "ان حصوں میں جائیں جو کوڈ کو محفوظ رکھتے ہیں جو دوسرے threads اور دوسری interfaces بھی استعمال کرتے ہیں: synchronized instance method اور synchronized static method کے درمیان فرق کہ کیا lock کرتے ہیں، کیوں volatile counter++ کے لیے visibility دیتا ہے لیکن atomicity نہیں، اور Java کیسے آپ کو default-method diamond کو ہاتھ سے حل کرنے پر مجبور کرتا ہے۔ Baeldung اور Java Concurrency in Practice کا Java Memory Model پر مواد دونوں کے لیے قدرتی اگلا مرحلہ ہے۔"
        },
        "expert": {
          "name": "ماہر",
          "desc": "آپ نے ہر سیکشن میں top اسکور کیا — core syntax اور types، OOP mechanics اور scope، collections اور generics، اور exceptions، concurrency اور idioms۔ عملی طور پر، اس کا مطلب ہے کہ آپ کو ایک اجنبی کی کلاس دی جا سکتی ہے اور آپ بتا سکتے ہیں کہ compile error، runtime exception، یا خاموشی سے غلط value کیوں ہوتی ہے، نہ صرف یہ کہ سنٹیکس کہتا ہے کہ اسے کیا کرنا چاہیے، جو زیادہ مشکل اور زیادہ قیمتی مہارت ہے۔ اس سطح پر خود زبان شاذ و نادر ہی محدود کرنے والا عامل ہے؛ حد عام طور پر concurrency design یا اس کے نیچے ڈیٹا کی شکل ہوتی ہے۔",
          "recommendation": "اب فوائل design اور diagnosis میں ہیں: thread dump پڑھنا قبل اس سے پہلے کہ hang کو deadlock سمجھیں، synchronized، java.util.concurrent locks اور atomics کے درمیان چننا ایک tradeoff کے طور پر ڈیفالٹ کی بجائے، اور stream-pipeline design جو purposefully lazy رہے حادثہ سے بجائے۔ اگر آپ کسی کردار کے لیے screened ہو رہے ہیں، تو concurrency bug بیان کریں جیسے missed happens-before edge یا ConcurrentModificationException جو آپ نے production میں ڈھونڈا، جاوا کی خصوصیات کا نام رکھنے کی بجائے — یہ استدلال کا مظاہرہ کرتا ہے، نہ صرف vocabulary۔"
        }
      },
      "questions": [
        {
          "question": "آپ دو String objects بناتے ہیں: String a = new String(\"cat\"); String b = new String(\"cat\"); a == b کا نتیجہ کیا ہے?",
          "options": [
            {
              "icon": "",
              "label": "true"
            },
            {
              "icon": "",
              "label": "یہ JVM کی string-pool setting پر منحصر ہے"
            },
            {
              "icon": "",
              "label": "ایک compile error"
            },
            {
              "icon": "",
              "label": "false"
            }
          ]
        },
        {
          "question": "Integer x = 100; Integer y = 100; System.out.println(x == y); پھر Integer x2 = 200; Integer y2 = 200; System.out.println(x2 == y2); یہ دونوں لائنیں کیا print کرتی ہیں?",
          "options": [
            {
              "icon": "",
              "label": "true پھر true"
            },
            {
              "icon": "",
              "label": "false پھر false"
            },
            {
              "icon": "",
              "label": "یہ compile نہیں ہوتا"
            },
            {
              "icon": "",
              "label": "true پھر false"
            }
          ]
        },
        {
          "question": "int max = Integer.MAX_VALUE; System.out.println(max + 1); کیا ہوتا ہے?",
          "options": [
            {
              "icon": "",
              "label": "یہ ArithmeticException throw کرتا ہے"
            },
            {
              "icon": "",
              "label": "یہ دوبارہ Integer.MAX_VALUE print کرتا ہے"
            },
            {
              "icon": "",
              "label": "یہ Integer.MIN_VALUE print کرتا ہے"
            },
            {
              "icon": "",
              "label": "ایک compile error"
            }
          ]
        },
        {
          "question": "System.out.println(0.1 + 0.2 == 0.3); یہ کیا print کرتا ہے، اور کیوں?",
          "options": [
            {
              "icon": "",
              "label": "false، کیونکہ binary floating point میں 0.1 اور 0.2 exact نہیں ہوتے"
            },
            {
              "icon": "",
              "label": "true، کیونکہ Java double sums کو قریب ترین decimal تک round کرتی ہے"
            },
            {
              "icon": "",
              "label": "true، کیونکہ دو decimal والی values ایک double میں exact جمع ہوتی ہیں"
            },
            {
              "icon": "",
              "label": "inexact comparison کی وجہ سے ArithmeticException throw ہوتا ہے"
            }
          ]
        },
        {
          "question": "ایک کلاس دو instance fields declare کرتی ہے بغیر initializer کے: int count; اور Integer total; constructor چلنے سے پہلے، ان کی default values کیا ہیں?",
          "options": [
            {
              "icon": "",
              "label": "دونوں 0 ہیں"
            },
            {
              "icon": "",
              "label": "assign ہونے تک کسی کی کوئی value نہیں ہوتی"
            },
            {
              "icon": "",
              "label": "count کی value 0 ہے اور total کی null"
            },
            {
              "icon": "",
              "label": "دونوں null ہیں"
            }
          ]
        },
        {
          "question": "ایک loop 1000 بار چلتا ہے، ہر بار String result پر result += \"x\"; کرتا ہے۔ ہر iteration میں under the hood اصل میں کیا ہوتا ہے?",
          "options": [
            {
              "icon": "",
              "label": "موجودہ String کا character array اسی جگہ بڑھا دیا جاتا ہے"
            },
            {
              "icon": "",
              "label": "Java تمام concatenations کو ایک final String میں اکٹھا کر دیتی ہے"
            },
            {
              "icon": "",
              "label": "تمام 1000 iterations میں ایک ہی StringBuilder share ہوتا ہے"
            },
            {
              "icon": "",
              "label": "ایک نیا String بنتا ہے اور result کو assign ہوتا ہے"
            }
          ]
        },
        {
          "question": "final List<String> names = new ArrayList<>(); ان میں سے کون سا سچ ہے?",
          "options": [
            {
              "icon": "",
              "label": "names.add(\"Ana\") compile ہو کر کام کرتا ہے"
            },
            {
              "icon": "",
              "label": "names.add(\"Ana\") compile نہیں ہوتا"
            },
            {
              "icon": "",
              "label": "یہ list بیک وقت ہونے والی writes کے لیے محفوظ ہے"
            },
            {
              "icon": "",
              "label": "local variable پر final کا کوئی اثر نہیں ہوتا"
            }
          ]
        },
        {
          "question": "int[] a = {1, 2, 3}; int[] b = {1, 2, 3}; System.out.println(a == b); System.out.println(Arrays.equals(a, b)); یہ دونوں لائنیں کیا print کرتی ہیں?",
          "options": [
            {
              "icon": "",
              "label": "false پھر true"
            },
            {
              "icon": "",
              "label": "true پھر true"
            },
            {
              "icon": "",
              "label": "false پھر false"
            },
            {
              "icon": "",
              "label": "یہ compile نہیں ہوتا"
            }
          ]
        },
        {
          "question": "void show(Object o) { print(\"Object\"); } void show(String s) { print(\"String\"); } Object ref = \"hello\"; show(ref); کون سا overload چلتا ہے، اور کیوں?",
          "options": [
            {
              "icon": "",
              "label": "show(String)، کیونکہ object کی runtime class String ہے"
            },
            {
              "icon": "",
              "label": "show(Object)، کیونکہ overload کا انتخاب declared type سے ہوتا ہے"
            },
            {
              "icon": "",
              "label": "کوئی نہیں؛ call مبہم ہے اور compile نہیں ہوتی"
            },
            {
              "icon": "",
              "label": "دونوں ایک ایک بار چلتے ہیں، کیونکہ ہر overload match کرتا ہے"
            }
          ]
        },
        {
          "question": "Class Base میں static void greet() { print(\"Base\"); } ہے۔ Class Derived، Base کو extend کرتی ہے اور static void greet() { print(\"Derived\"); } بھی declare کرتی ہے۔ آپ لکھتے ہیں: Base ref = new Derived(); ref.greet(); کیا print ہوگا؟",
          "options": [
            {
              "icon": "",
              "label": "Derived"
            },
            {
              "icon": "",
              "label": "یہ compile نہیں ہوتا"
            },
            {
              "icon": "",
              "label": "Base"
            },
            {
              "icon": "",
              "label": "پہلے Base، پھر Derived"
            }
          ]
        },
        {
          "question": "ایک method میں آپ int count = 0; لکھتے ہیں؛ پھر count کو دوسری method میں pass کیے گئے lambda کے اندر سے reference کرنے کی کوشش کرتے ہیں۔ اس کے compile ہونے کے لیے count کے بارے میں کیا سچ ہونا چاہیے؟",
          "options": [
            {
              "icon": "",
              "label": "اسے final یا effectively final ہونا چاہیے"
            },
            {
              "icon": "",
              "label": "کچھ نہیں؛ کوئی بھی local چلے گا"
            },
            {
              "icon": "",
              "label": "اسے volatile declare کرنا ضروری ہے"
            },
            {
              "icon": "",
              "label": "اسے field ہونا چاہیے، local نہیں"
            }
          ]
        },
        {
          "question": "void rename(StringBuilder sb) { sb = new StringBuilder(\"new\"); } کو StringBuilder original = new StringBuilder(\"old\"); rename(original); سے call کیا جاتا ہے۔ Call کے بعد original کیا ہے؟",
          "options": [
            {
              "icon": "",
              "label": "یہ \"new\" ہے"
            },
            {
              "icon": "",
              "label": "یہ null ہے"
            },
            {
              "icon": "",
              "label": "یہ اب بھی \"old\" ہے"
            },
            {
              "icon": "",
              "label": "ایک runtime exception throw ہوتا ہے"
            }
          ]
        },
        {
          "question": "ایک class میں static initializer block، instance initializer block، اور constructor ہے، اسی ترتیب میں۔ آپ اس class کے دو objects ایک کے بعد ایک بناتے ہیں۔ یہ کس ترتیب میں چلتے ہیں؟",
          "options": [
            {
              "icon": "",
              "label": "Static block ایک بار؛ پھر ہر object کے لیے instance block، پھر constructor"
            },
            {
              "icon": "",
              "label": "ہر object کے لیے تینوں source order میں چلتے ہیں"
            },
            {
              "icon": "",
              "label": "ہر object کے لیے constructor پھر instance block؛ آخر میں static block ایک بار"
            },
            {
              "icon": "",
              "label": "ہر object پر static block ایک بار، پھر instance block، پھر constructor"
            }
          ]
        },
        {
          "question": "ایک class میں void log(String s) اور void log(String... args) ہے۔ آپ log(\"hi\") کو call کرتے ہیں۔ کون سا چلتا ہے؟",
          "options": [
            {
              "icon": "",
              "label": "log(String... args)"
            },
            {
              "icon": "",
              "label": "ایک compile error: call مبہم ہے"
            },
            {
              "icon": "",
              "label": "log(String s)"
            },
            {
              "icon": "",
              "label": "جو overload پہلے declare ہوا ہو"
            }
          ]
        },
        {
          "question": "ایک constructor کی پہلی لائن this(0); کو call کرتی ہے تاکہ اسی class میں دوسری constructor کو delegate کیا جاسکے۔ یہ کہاں ظاہر ہونے کی اجازت ہے؟",
          "options": [
            {
              "icon": "",
              "label": "body میں کہیں بھی، constructor کے return ہونے سے پہلے"
            },
            {
              "icon": "",
              "label": "صرف constructor کی پہلی statement کے طور پر"
            },
            {
              "icon": "",
              "label": "صرف constructor کی سب سے آخری statement کے طور پر"
            },
            {
              "icon": "",
              "label": "صرف delegate keyword والے constructor میں"
            }
          ]
        },
        {
          "question": "آپ کو ایک list چاہیے جس میں elements بہت بار front میں insert ہوں، اور random-access reads کم ہوں۔ بہتر structural fit کون سا ہے، اور کیوں؟",
          "options": [
            {
              "icon": "",
              "label": "ArrayList، کیونکہ اس کا backing array front inserts کو سب سے تیز بناتا ہے"
            },
            {
              "icon": "",
              "label": "کوئی بھی، کیونکہ دونوں ایک جیسی guarantees کے ساتھ List implement کرتے ہیں"
            },
            {
              "icon": "",
              "label": "LinkedList، کیونکہ front insertion O(n) کے بجائے O(1) ہے"
            },
            {
              "icon": "",
              "label": "LinkedList، کیونکہ یہ O(1) random access دیتی ہے"
            }
          ]
        },
        {
          "question": "آپ پانچ entries کو ایک plain HashMap میں specific order میں insert کرتے ہیں، پھر اس پر for-each loop سے iterate کرتے ہیں۔ Entries کس ترتیب میں نکلتی ہیں؟",
          "options": [
            {
              "icon": "",
              "label": "insertion کی ترتیب میں"
            },
            {
              "icon": "",
              "label": "کوئی guaranteed ترتیب نہیں"
            },
            {
              "icon": "",
              "label": "key کے مطابق sorted"
            },
            {
              "icon": "",
              "label": "insert کرنے کی الٹی ترتیب میں"
            }
          ]
        },
        {
          "question": "ایک plain java.util.HashMap ایک وقت میں کتنی null keys رکھ سکتا ہے، اور کتنی null values؟",
          "options": [
            {
              "icon": "",
              "label": "نہ کوئی null key، نہ کوئی null value"
            },
            {
              "icon": "",
              "label": "ایک null key، اور null values کتنی بھی"
            },
            {
              "icon": "",
              "label": "null keys یا values کتنی بھی"
            },
            {
              "icon": "",
              "label": "ایک null key اور ایک null value"
            }
          ]
        },
        {
          "question": "آپ ایک List کو for-each loop سے iterate کرتے ہیں اور loop body کے اندر سے list.remove(item) کو براہ راست list پر call کرتے ہیں، کچھ لیکن سب نہیں elements پر۔ کیا ہوتا ہے؟",
          "options": [
            {
              "icon": "",
              "label": "یہ بالکل مطلوبہ elements ہی remove کرتا ہے"
            },
            {
              "icon": "",
              "label": "یہ انہیں remove کرتا ہے، مگر صرف loop ختم ہونے کے بعد"
            },
            {
              "icon": "",
              "label": "یہ IndexOutOfBoundsException throw کرتا ہے"
            },
            {
              "icon": "",
              "label": "یہ ConcurrentModificationException throw کرتا ہے"
            }
          ]
        },
        {
          "question": "Runtime میں، ایک List<String> list دیتے ہوئے، آپ اپنے generic type parameter کے بارے میں reflection یا instanceof کے ذریعے اصل میں کیا determine کر سکتے ہیں؟",
          "options": [
            {
              "icon": "",
              "label": "list.getElementType() سے String.class واپس آتی ہے"
            },
            {
              "icon": "",
              "label": "instanceof List<String> element type کو check کرتا ہے"
            },
            {
              "icon": "",
              "label": "JVM اسے metadata کے طور پر رکھتی ہے جسے getGenericType() سے پڑھا جا سکتا ہے"
            },
            {
              "icon": "",
              "label": "element type کے بارے میں کچھ بھی نہیں"
            }
          ]
        },
        {
          "question": "switch (day) { case 1: case 2: print(\"Weekday\"); break; case 6: print(\"Saturday\"); case 7: print(\"Sunday\"); break; default: print(\"?\"); } اگر day 6 ہے، کیا print ہوگا؟",
          "options": [
            {
              "icon": "",
              "label": "صرف Saturday"
            },
            {
              "icon": "",
              "label": "صرف Sunday"
            },
            {
              "icon": "",
              "label": "Saturday، Sunday، پھر ?"
            },
            {
              "icon": "",
              "label": "Saturday، پھر Sunday"
            }
          ]
        },
        {
          "question": "ایک Product class کو ایک واحد، واضح \"natural\" sort order price کے ذریعے چاہیے، نیز نام یا stock level کے ذریعے sort کرنے کی صلاحیت codebase میں مختلف جگہوں میں۔ کون سا combination صحیح design ہے؟",
          "options": [
            {
              "icon": "",
              "label": "Comparable<Product> کو تین الگ الگ بار implement کرنا"
            },
            {
              "icon": "",
              "label": "price کے لیے Comparable، اور name اور stock کے لیے الگ Comparators"
            },
            {
              "icon": "",
              "label": "name کے لیے Comparable، اور price اور stock کے لیے Comparators"
            },
            {
              "icon": "",
              "label": "تین overloaded compareTo methods والا ایک Comparable"
            }
          ]
        },
        {
          "question": "ایک method new FileReader(path) کو call کرتا ہے، جو throws IOException declare کرتا ہے۔ IOException Exception کو extend کرتا ہے، RuntimeException نہیں۔ اس کے compile ہونے کے لیے آپ کو کیا کرنا ہوگا؟",
          "options": [
            {
              "icon": "",
              "label": "کچھ نہیں؛ یہ جیسا لکھا ہے ویسے ہی compile ہو جاتا ہے"
            },
            {
              "icon": "",
              "label": "IOException کو catch کریں یا throws IOException declare کریں"
            },
            {
              "icon": "",
              "label": "call کے گرد RuntimeException کو catch کریں"
            },
            {
              "icon": "",
              "label": "method کو static declare کریں"
            }
          ]
        },
        {
          "question": "try (Resource a = new Resource(\"A\"); Resource b = new Resource(\"B\")) { ... } دو resources استعمال کرتا ہے جو AutoCloseable implement کرتے ہیں۔ اگر try block عام طریقے سے ختم ہو تو وہ کس ترتیب میں close ہوتے ہیں؟",
          "options": [
            {
              "icon": "",
              "label": "declaration کی ترتیب میں، A پھر B"
            },
            {
              "icon": "",
              "label": "پہلے B، پھر A"
            },
            {
              "icon": "",
              "label": "دونوں ایک ہی وقت میں"
            },
            {
              "icon": "",
              "label": "صرف B خود بخود close ہوتا ہے"
            }
          ]
        },
        {
          "question": "int getValue() { try { return 1; } finally { return 2; } } getValue() کو کال کرنے سے کیا واپس ملتا ہے؟",
          "options": [
            {
              "icon": "",
              "label": "1"
            },
            {
              "icon": "",
              "label": "یہ ایک exception throw کرتا ہے"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "یہ compile نہیں ہوتا"
            }
          ]
        },
        {
          "question": "try { ... } catch (IOException e) { ... } catch (FileNotFoundException e) { ... }، اور FileNotFoundException IOException کو extend کرتا ہے۔ جب آپ اس کو compile کرنے کی کوشش کرتے ہیں تو کیا ہوتا ہے؟",
          "options": [
            {
              "icon": "",
              "label": "ناقابلِ رسائی دوسرے catch block کی وجہ سے compile error آتا ہے"
            },
            {
              "icon": "",
              "label": "یہ compile ہو جاتا ہے؛ FileNotFoundException block اس type کو handle کرتا ہے"
            },
            {
              "icon": "",
              "label": "یہ compile ہوتا ہے، اور دونوں catch blocks باری باری چلتے ہیں"
            },
            {
              "icon": "",
              "label": "یہ compile ہو جاتا ہے مگر FileNotFoundException پر runtime میں fail ہوتا ہے"
            }
          ]
        },
        {
          "question": "ایک کلاس میں synchronized instance method process() اور synchronized static method configure() ہے۔ خاص طور پر، ہر ایک کیا lock کرتا ہے؟",
          "options": [
            {
              "icon": "",
              "label": "process() instance کو lock کرتا ہے؛ configure() Class object کو"
            },
            {
              "icon": "",
              "label": "دونوں ایک global JVM-wide lock لگاتے ہیں"
            },
            {
              "icon": "",
              "label": "process() Class object کو lock کرتا ہے؛ configure() caller instance کو"
            },
            {
              "icon": "",
              "label": "اندر synchronized block کے بغیر کوئی بھی کچھ lock نہیں کرتا"
            }
          ]
        },
        {
          "question": "ایک field volatile int counter = 0; declare کیا جاتا ہے، اور متعدد threads اس پر counter++ چلاتے ہیں بیک وقت۔ کیا volatile یہاں lost updates کو روکتا ہے؟",
          "options": [
            {
              "icon": "",
              "label": "ہاں"
            },
            {
              "icon": "",
              "label": "نہیں"
            },
            {
              "icon": "",
              "label": "صرف int اور long fields کے لیے"
            },
            {
              "icon": "",
              "label": "صرف اگر field static بھی ہو"
            }
          ]
        },
        {
          "question": "Interface A اور interface B ہر ایک ایک default method describe() declare کرتے ہیں۔ ایک کلاس دونوں A اور B کو implement کرتی ہے اور خود describe() کو override نہیں کرتی۔ کیا ہوتا ہے؟",
          "options": [
            {
              "icon": "",
              "label": "A کا version چلتا ہے، کیونکہ A پہلے لکھا گیا ہے"
            },
            {
              "icon": "",
              "label": "دونوں versions ایک کے بعد ایک چلتے ہیں"
            },
            {
              "icon": "",
              "label": "یہ compile ہو جاتا ہے مگر call کرنے پر exception throw کرتا ہے"
            },
            {
              "icon": "",
              "label": "compile error آتا ہے، جب تک class خود describe() کو override نہ کرے"
            }
          ]
        },
        {
          "question": "list.stream().filter(x -> x > 0).map(x -> x * 2); لکھا جاتا ہے لیکن result کبھی .collect() یا .forEach() جیسے terminal operation میں assign نہیں کیا جاتا۔ جب یہ لائن execute ہوتی ہے تو اصل میں کیا ہوتا ہے؟",
          "options": [
            {
              "icon": "",
              "label": "کچھ نہیں؛ pipeline کبھی نہیں چلتی"
            },
            {
              "icon": "",
              "label": "ہر element فوراً filter اور map ہوتا ہے"
            },
            {
              "icon": "",
              "label": "صرف filter چلتا ہے؛ map کسی terminal operation کا انتظار کرتا ہے"
            },
            {
              "icon": "",
              "label": "یہ IllegalStateException throw کرتا ہے"
            }
          ]
        }
      ],
      "optionOrderVersion": "9d7b97ef6cccf4e2"
    }
  },
  "testNames": {
    "java-test": "Java ٹیسٹ"
  }
}