LuaJIT и FFI — бесплатный тест онлайн

Вопрос 1 из 30

Какая семантическая деталь определяет поведение фрагмента? Ответ должен описывать основной механизм раздела «JIT-компиляция».

local jit=require("jit")
local util=require("jit.util")
for i=1,100000 do hot_path(i%3) end
print(jit.status(),util.traceinfo(1))

При разборе раздела «JIT-компиляция» здесь действует условие: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор. При разборе раздела «JIT-компиляция» здесь действует условие: FFI тесно связан с LuaJIT и ABI платформы; код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. При разборе раздела «JIT-компиляция» здесь действует условие: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами. При разборе раздела «JIT-компиляция» здесь действует условие: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. При разборе раздела «JIT-компиляция» здесь действует условие: Критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей.

Вопрос 2 из 30

Какое допущение здесь опасно оставлять без повторного запуска? Ищется граничное следствие правила из раздела «JIT-компиляция».

local function reproduce_case()
  local jit=require("jit")
  local util=require("jit.util")
  for i=1,100000 do hot_path(i%3) end
  print(jit.status(),util.traceinfo(1))
end
reproduce_case()

Повторный запуск в разделе «JIT-компиляция» должен выявить: Сбой нативной функции способен завершить весь процесс, минуя pcall. Повторный запуск в разделе «JIT-компиляция» должен выявить: Совпавший результат одного вызова не доказывает правильную сигнатуру. Повторный запуск в разделе «JIT-компиляция» должен выявить: ffi.gc помогает с освобождением, но не предотвращает use-after-free. Повторный запуск в разделе «JIT-компиляция» должен выявить: FFI тесно связан с LuaJIT и ABI платформы. Повторный запуск в разделе «JIT-компиляция» должен выявить: Оценивать нужно профиль трасс, а не наличие JIT как такового.

Вопрос 3 из 30

Какой результат обязан подтверждать регрессионный тест после правки? Выберите гарантию, определяющую раздел «JIT-компиляция».

do
  local jit=require("jit")
  local util=require("jit.util")
  for i=1,100000 do hot_path(i%3) end
  print(jit.status(),util.traceinfo(1))
end

Внешнее поведение раздела «JIT-компиляция» сохраняется при условии: Критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Внешнее поведение раздела «JIT-компиляция» сохраняется при условии: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор. Внешнее поведение раздела «JIT-компиляция» сохраняется при условии: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами. Внешнее поведение раздела «JIT-компиляция» сохраняется при условии: FFI тесно связан с LuaJIT и ABI платформы; код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. Внешнее поведение раздела «JIT-компиляция» сохраняется при условии: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free.

Вопрос 4 из 30

Какой принцип сделает реализацию «JIT-компиляция» устойчивой, а не просто удачной на одном примере? Ответ должен выражать проверяемое следствие раздела «JIT-компиляция».

Для эксплуатации раздела «JIT-компиляция» важно зафиксировать: Сбой нативной функции способен завершить весь процесс, минуя pcall. Для эксплуатации раздела «JIT-компиляция» важно зафиксировать: Совпавший результат одного вызова не доказывает правильную сигнатуру. Для эксплуатации раздела «JIT-компиляция» важно зафиксировать: Оценивать нужно профиль трасс, а не наличие JIT как такового. Для эксплуатации раздела «JIT-компиляция» важно зафиксировать: ffi.gc помогает с освобождением, но не предотвращает use-after-free. Для эксплуатации раздела «JIT-компиляция» важно зафиксировать: FFI тесно связан с LuaJIT и ABI платформы.

Вопрос 5 из 30

Что помогает не переносить в раздел «JIT-компиляция» привычки из другого языка или среды? Нужна полная формулировка раздела «JIT-компиляция».

При проектировании раздела «JIT-компиляция» нужно помнить: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. При проектировании раздела «JIT-компиляция» нужно помнить: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор; оценивать нужно профиль трасс, а не наличие JIT как такового. При проектировании раздела «JIT-компиляция» нужно помнить: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. При проектировании раздела «JIT-компиляция» нужно помнить: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. При проектировании раздела «JIT-компиляция» нужно помнить: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти.

Вопрос 6 из 30

Почему этот фрагмент ведёт себя именно так? Нужна именно центральная гарантия раздела «FFI-типы».

local ffi=require("ffi")
ffi.cdef[[typedef struct { int x; int y; } Point;
          int distance2(const Point *p);]]
local lib=ffi.load("geometry")
local p=ffi.new("Point",{3,4})
print(lib.distance2(p))

Центральный механизм раздела «FFI-типы»: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор; оценивать нужно профиль трасс, а не наличие JIT как такового. Центральный механизм раздела «FFI-типы»: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Центральный механизм раздела «FFI-типы»: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. Центральный механизм раздела «FFI-типы»: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. Центральный механизм раздела «FFI-типы»: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти.

Вопрос 7 из 30

Какой отказ должен быть воспроизводимым в тесте? Выберите именно проверяемую границу раздела «FFI-типы».

local function reproduce_case()
  local ffi=require("ffi")
  ffi.cdef[[typedef struct { int x; int y; } Point;
            int distance2(const Point *p);]]
  local lib=ffi.load("geometry")
  local p=ffi.new("Point",{3,4})
  print(lib.distance2(p))
end
reproduce_case()

Скрытая граница раздела «FFI-типы» проявляется так: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Скрытая граница раздела «FFI-типы» проявляется так: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор; оценивать нужно профиль трасс, а не наличие JIT как такового. Скрытая граница раздела «FFI-типы» проявляется так: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. Скрытая граница раздела «FFI-типы» проявляется так: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. Скрытая граница раздела «FFI-типы» проявляется так: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей.

Вопрос 8 из 30

Какой результат обязан подтверждать регрессионный тест после правки? Речь идёт о центральном правиле раздела «FFI-типы».

do
  local ffi=require("ffi")
  ffi.cdef[[typedef struct { int x; int y; } Point;
            int distance2(const Point *p);]]
  local lib=ffi.load("geometry")
  local p=ffi.new("Point",{3,4})
  print(lib.distance2(p))
end

При замене внутренних шагов раздела «FFI-типы» остаётся гарантия: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. При замене внутренних шагов раздела «FFI-типы» остаётся гарантия: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. При замене внутренних шагов раздела «FFI-типы» остаётся гарантия: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. При замене внутренних шагов раздела «FFI-типы» остаётся гарантия: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. При замене внутренних шагов раздела «FFI-типы» остаётся гарантия: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор; оценивать нужно профиль трасс, а не наличие JIT как такового.

Вопрос 9 из 30

В проекте пересматривают «FFI-типы». Какое правило лучше выразить в интерфейсе, а не оставлять устной договорённостью? Выберите практическое следствие раздела «FFI-типы».

Рабочий контракт раздела «FFI-типы» делает наблюдаемым: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор; оценивать нужно профиль трасс, а не наличие JIT как такового. Рабочий контракт раздела «FFI-типы» делает наблюдаемым: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. Рабочий контракт раздела «FFI-типы» делает наблюдаемым: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. Рабочий контракт раздела «FFI-типы» делает наблюдаемым: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Рабочий контракт раздела «FFI-типы» делает наблюдаемым: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти.

Вопрос 10 из 30

Какой вывод о разделе «FFI-типы» останется верным после смены реализации? Нужна полная формулировка раздела «FFI-типы».

Механизм и граница раздела «FFI-типы» описываются так: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Механизм и граница раздела «FFI-типы» описываются так: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. Механизм и граница раздела «FFI-типы» описываются так: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Механизм и граница раздела «FFI-типы» описываются так: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. Механизм и граница раздела «FFI-типы» описываются так: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор; оценивать нужно профиль трасс, а не наличие JIT как такового.

Вопрос 11 из 30

В чём ключ к разбору строки «local p=ffi.gc(lib.buffer_new(4096),lib.buffer_free)»? Нужна именно центральная гарантия раздела «Граница C».

local ffi=require("ffi")
ffi.cdef[[void *buffer_new(size_t n); void buffer_free(void *p);]]
local p=ffi.gc(lib.buffer_new(4096),lib.buffer_free)
assert(p~=nil)
use_buffer(p,4096)
p=nil; collectgarbage()

Поведение строки из раздела «Граница C» определяется правилом: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке. Поведение строки из раздела «Граница C» определяется правилом: Критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Поведение строки из раздела «Граница C» определяется правилом: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов. Поведение строки из раздела «Граница C» определяется правилом: Неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Поведение строки из раздела «Граница C» определяется правилом: Код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации.

Вопрос 12 из 30

Что должен поймать отрицательный тест для этого фрагмента? Ищется граничное следствие правила из раздела «Граница C».

local function reproduce_case()
  local ffi=require("ffi")
  ffi.cdef[[void *buffer_new(size_t n); void buffer_free(void *p);]]
  local p=ffi.gc(lib.buffer_new(4096),lib.buffer_free)
  assert(p~=nil)
  use_buffer(p,4096)
  p=nil; collectgarbage()
end
reproduce_case()

Отрицательный сценарий для раздела «Граница C» фиксирует: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Отрицательный сценарий для раздела «Граница C» фиксирует: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. Отрицательный сценарий для раздела «Граница C» фиксирует: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Отрицательный сценарий для раздела «Граница C» фиксирует: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. Отрицательный сценарий для раздела «Граница C» фиксирует: FFI тесно связан с LuaJIT и ABI платформы; код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации.

Вопрос 13 из 30

Что нужно проверить после замены реализации? Речь идёт о центральном правиле раздела «Граница C».

do
  local ffi=require("ffi")
  ffi.cdef[[void *buffer_new(size_t n); void buffer_free(void *p);]]
  local p=ffi.gc(lib.buffer_new(4096),lib.buffer_free)
  assert(p~=nil)
  use_buffer(p,4096)
  p=nil; collectgarbage()
end

Внешнее поведение раздела «Граница C» сохраняется при условии: Критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Внешнее поведение раздела «Граница C» сохраняется при условии: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке. Внешнее поведение раздела «Граница C» сохраняется при условии: Код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. Внешнее поведение раздела «Граница C» сохраняется при условии: Неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Внешнее поведение раздела «Граница C» сохраняется при условии: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов.

Вопрос 14 из 30

В модуле меняют «Граница C» и хотят сохранить диагностируемость. Какой подход надёжнее? Выберите практическое следствие раздела «Граница C».

В разделе «Граница C» нельзя оставлять неявным условие: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. В разделе «Граница C» нельзя оставлять неявным условие: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. В разделе «Граница C» нельзя оставлять неявным условие: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. В разделе «Граница C» нельзя оставлять неявным условие: FFI тесно связан с LuaJIT и ABI платформы; код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. В разделе «Граница C» нельзя оставлять неявным условие: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей.

Вопрос 15 из 30

Какое правило раздела «Граница C» стоит закрепить в тестах? Ответ должен охватывать весь раздел «Граница C».

Для обычного и граничного сценария раздела «Граница C» справедливо: FFI тесно связан с LuaJIT и ABI платформы; код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. Для обычного и граничного сценария раздела «Граница C» справедливо: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Для обычного и граничного сценария раздела «Граница C» справедливо: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Для обычного и граничного сценария раздела «Граница C» справедливо: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. Для обычного и граничного сценария раздела «Граница C» справедливо: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free.

Вопрос 16 из 30

Какая семантическая деталь определяет поведение фрагмента? Выберите основное правило раздела «Переносимость».

local ffi=require("ffi")
if ffi.os=="Windows" then
  lib=ffi.load("service.dll")
else
  lib=ffi.load("libservice.so")
end

При разборе раздела «Переносимость» здесь действует условие: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. При разборе раздела «Переносимость» здесь действует условие: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. При разборе раздела «Переносимость» здесь действует условие: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами. При разборе раздела «Переносимость» здесь действует условие: FFI тесно связан с LuaJIT и ABI платформы; код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. При разборе раздела «Переносимость» здесь действует условие: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор.

Вопрос 17 из 30

Что здесь важнее проверить, чем само отсутствие ошибки? Нужен отрицательный сценарий для раздела «Переносимость».

local function reproduce_case()
  local ffi=require("ffi")
  if ffi.os=="Windows" then
    lib=ffi.load("service.dll")
  else
    lib=ffi.load("libservice.so")
  end
end
reproduce_case()

Регрессионная проверка раздела «Переносимость» наблюдает следующее: Критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Регрессионная проверка раздела «Переносимость» наблюдает следующее: Код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. Регрессионная проверка раздела «Переносимость» наблюдает следующее: Неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Регрессионная проверка раздела «Переносимость» наблюдает следующее: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов. Регрессионная проверка раздела «Переносимость» наблюдает следующее: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке.

Вопрос 18 из 30

Что нельзя считать деталью реализации в этом коде? Нужен основной контракт раздела «Переносимость».

do
  local ffi=require("ffi")
  if ffi.os=="Windows" then
    lib=ffi.load("service.dll")
  else
    lib=ffi.load("libservice.so")
  end
end

Эквивалентный рефакторинг раздела «Переносимость» сохраняет следующее: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. Эквивалентный рефакторинг раздела «Переносимость» сохраняет следующее: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами. Эквивалентный рефакторинг раздела «Переносимость» сохраняет следующее: FFI тесно связан с LuaJIT и ABI платформы; код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. Эквивалентный рефакторинг раздела «Переносимость» сохраняет следующее: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Эквивалентный рефакторинг раздела «Переносимость» сохраняет следующее: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор.

Вопрос 19 из 30

Какое решение по разделу «Переносимость» упростит и проверку, и расследование сбоя? Ответ должен выражать проверяемое следствие раздела «Переносимость».

Для диагностируемого решения раздела «Переносимость» требуется: Неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Для диагностируемого решения раздела «Переносимость» требуется: Критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Для диагностируемого решения раздела «Переносимость» требуется: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке. Для диагностируемого решения раздела «Переносимость» требуется: Код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. Для диагностируемого решения раздела «Переносимость» требуется: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов.

Вопрос 20 из 30

Какое утверждение о разделе «Переносимость» точно и не обещает лишнего? Ответ должен охватывать весь раздел «Переносимость».

Для раздела «Переносимость» верно: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор. Для раздела «Переносимость» верно: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Для раздела «Переносимость» верно: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами. Для раздела «Переносимость» верно: FFI тесно связан с LuaJIT и ABI платформы; код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. Для раздела «Переносимость» верно: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free.

Вопрос 21 из 30

На каком правиле держится поведение этого кода? Выберите основное правило раздела «Проверка корректности».

assert(ffi.sizeof("Point")==8)
local p=ffi.new("Point",{x=-1,y=2147483647})
assert(lib.validate(p)==reference_validate(-1,2147483647))

Центральный механизм раздела «Проверка корректности»: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Центральный механизм раздела «Проверка корректности»: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. Центральный механизм раздела «Проверка корректности»: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор; оценивать нужно профиль трасс, а не наличие JIT как такового. Центральный механизм раздела «Проверка корректности»: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Центральный механизм раздела «Проверка корректности»: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру.

Вопрос 22 из 30

Где этот код может повести себя иначе на границе? Ищется граничное следствие правила из раздела «Проверка корректности».

local function reproduce_case()
  assert(ffi.sizeof("Point")==8)
  local p=ffi.new("Point",{x=-1,y=2147483647})
  assert(lib.validate(p)==reference_validate(-1,2147483647))
end
reproduce_case()

На другом входе раздела «Проверка корректности» нужно проверить: Оценивать нужно профиль трасс, а не наличие JIT как такового. На другом входе раздела «Проверка корректности» нужно проверить: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке. На другом входе раздела «Проверка корректности» нужно проверить: Сбой нативной функции способен завершить весь процесс, минуя pcall. На другом входе раздела «Проверка корректности» нужно проверить: Совпавший результат одного вызова не доказывает правильную сигнатуру. На другом входе раздела «Проверка корректности» нужно проверить: ffi.gc помогает с освобождением, но не предотвращает use-after-free.

Вопрос 23 из 30

Какое правило должно остаться наблюдаемым после правки? Речь идёт о центральном правиле раздела «Проверка корректности».

do
  assert(ffi.sizeof("Point")==8)
  local p=ffi.new("Point",{x=-1,y=2147483647})
  assert(lib.validate(p)==reference_validate(-1,2147483647))
end

В разделе «Проверка корректности» нельзя потерять правило: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. В разделе «Проверка корректности» нельзя потерять правило: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор; оценивать нужно профиль трасс, а не наличие JIT как такового. В разделе «Проверка корректности» нельзя потерять правило: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. В разделе «Проверка корректности» нельзя потерять правило: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. В разделе «Проверка корректности» нельзя потерять правило: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей.

Вопрос 24 из 30

Новый интерфейс скрывает детали раздела «Проверка корректности». Что всё равно должно быть явно проверяемо? Нужна эксплуатационная граница раздела «Проверка корректности».

Код и тесты раздела «Проверка корректности» должны выражать правило: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке. Код и тесты раздела «Проверка корректности» должны выражать правило: Сбой нативной функции способен завершить весь процесс, минуя pcall. Код и тесты раздела «Проверка корректности» должны выражать правило: ffi.gc помогает с освобождением, но не предотвращает use-after-free. Код и тесты раздела «Проверка корректности» должны выражать правило: Совпавший результат одного вызова не доказывает правильную сигнатуру. Код и тесты раздела «Проверка корректности» должны выражать правило: Оценивать нужно профиль трасс, а не наличие JIT как такового.

Вопрос 25 из 30

Какое утверждение о разделе «Проверка корректности» полезно и при чтении кода, и при ревью? Ответ должен охватывать весь раздел «Проверка корректности».

Полная гарантия раздела «Проверка корректности» звучит так: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор; оценивать нужно профиль трасс, а не наличие JIT как такового. Полная гарантия раздела «Проверка корректности» звучит так: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру. Полная гарантия раздела «Проверка корректности» звучит так: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Полная гарантия раздела «Проверка корректности» звучит так: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Полная гарантия раздела «Проверка корректности» звучит так: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free.

Вопрос 26 из 30

Какая семантическая деталь определяет поведение фрагмента? Выберите основное правило раздела «Устойчивость к сбоям».

local result=run_native_in_worker({library=path,symbol="decode",data=input})
if result.signal then
  mark_unhealthy(path,result.signal)
  return nil,"native decoder crashed"
end

При разборе раздела «Устойчивость к сбоям» здесь действует условие: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке. При разборе раздела «Устойчивость к сбоям» здесь действует условие: Оценивать нужно профиль трасс, а не наличие JIT как такового. При разборе раздела «Устойчивость к сбоям» здесь действует условие: ffi.gc помогает с освобождением, но не предотвращает use-after-free. При разборе раздела «Устойчивость к сбоям» здесь действует условие: Сбой нативной функции способен завершить весь процесс, минуя pcall. При разборе раздела «Устойчивость к сбоям» здесь действует условие: Совпавший результат одного вызова не доказывает правильную сигнатуру.

Вопрос 27 из 30

Что должен поймать отрицательный тест для этого фрагмента? Нужен отрицательный сценарий для раздела «Устойчивость к сбоям».

local function reproduce_case()
  local result=run_native_in_worker({library=path,symbol="decode",data=input})
  if result.signal then
    mark_unhealthy(path,result.signal)
    return nil,"native decoder crashed"
  end
end
reproduce_case()

Другой вход в разделе «Устойчивость к сбоям» должен сделать видимым: Неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Другой вход в разделе «Устойчивость к сбоям» должен сделать видимым: Код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. Другой вход в разделе «Устойчивость к сбоям» должен сделать видимым: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами. Другой вход в разделе «Устойчивость к сбоям» должен сделать видимым: Критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Другой вход в разделе «Устойчивость к сбоям» должен сделать видимым: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов.

Вопрос 28 из 30

После рефакторинга тесты должны защищать одно правило. Какое? Речь идёт о центральном правиле раздела «Устойчивость к сбоям».

do
  local result=run_native_in_worker({library=path,symbol="decode",data=input})
  if result.signal then
    mark_unhealthy(path,result.signal)
    return nil,"native decoder crashed"
  end
end

Контракт рефакторинга раздела «Устойчивость к сбоям»: Совпавший результат одного вызова не доказывает правильную сигнатуру. Контракт рефакторинга раздела «Устойчивость к сбоям»: ffi.gc помогает с освобождением, но не предотвращает use-after-free. Контракт рефакторинга раздела «Устойчивость к сбоям»: Оценивать нужно профиль трасс, а не наличие JIT как такового. Контракт рефакторинга раздела «Устойчивость к сбоям»: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке. Контракт рефакторинга раздела «Устойчивость к сбоям»: Сбой нативной функции способен завершить весь процесс, минуя pcall.

Вопрос 29 из 30

Для раздела «Устойчивость к сбоям» выбирают между коротким трюком и ясным контрактом. Что предпочтительнее? Выберите практическое следствие раздела «Устойчивость к сбоям».

Рабочий контракт раздела «Устойчивость к сбоям» делает наблюдаемым: Код на стандартном Lua, другой архитектуре или Windows может потребовать иной путь реализации. Рабочий контракт раздела «Устойчивость к сбоям» делает наблюдаемым: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами. Рабочий контракт раздела «Устойчивость к сбоям» делает наблюдаемым: Неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Рабочий контракт раздела «Устойчивость к сбоям» делает наблюдаемым: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов. Рабочий контракт раздела «Устойчивость к сбоям» делает наблюдаемым: Критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей.

Вопрос 30 из 30

На какое утверждение можно опереться при проектировании раздела «Устойчивость к сбоям»? Нужна полная формулировка раздела «Устойчивость к сбоям».

Полная гарантия раздела «Устойчивость к сбоям» звучит так: Ffi.cdef объявляет C-типы и функции, но не проверяет соответствие фактической библиотеке; неверная сигнатура, размер структуры или calling convention приводят к повреждению памяти. Полная гарантия раздела «Устойчивость к сбоям» звучит так: Сбой нативной функции способен завершить весь процесс, минуя pcall; критичные и недоверенные библиотеки изолируют процессом и контролируют версии бинарных зависимостей. Полная гарантия раздела «Устойчивость к сбоям» звучит так: На границе FFI нужно определить владение указателями, длины буферов и срок жизни Lua-объектов; ffi.gc помогает с освобождением, но не предотвращает use-after-free. Полная гарантия раздела «Устойчивость к сбоям» звучит так: LuaJIT компилирует горячие трассы, но side exit, редкие типы и неподдерживаемые операции могут вернуть выполнение в интерпретатор; оценивать нужно профиль трасс, а не наличие JIT как такового. Полная гарантия раздела «Устойчивость к сбоям» звучит так: Корректность FFI проверяют эталонными C-тестами, размерами типов, нулевыми указателями и санитайзерами; совпавший результат одного вызова не доказывает правильную сигнатуру.