Более

Что-нибудь, связанное с Python, вызывает сбой ArcGIS for Desktop?


Проблема: ArcMap 10.3 вылетает на рабочий стол каждый раз, когда я использую функцию, связанную с Python (панели инструментов, вычислитель поля и т. Д.)

Как я дошел до этой точки: Я пытался немного познакомиться с программированием на Python и решил использовать руководство Learn Python The Hard Way.
Это включало загрузку, установку Python и настройку вашей среды с помощью Powershell.
Я считаю, что это вызвало некоторые проблемы, поскольку после установки ArcGIS уже была установлена ​​установка Python. На моем основном жестком диске уже была папка «Python27».

Вопрос: Как мне указать моему ArcMap искать Python в папке «Python27 ArcGIS10.3»? Я бы предпочел не переустанавливать ArcGIS полностью.

Скриншоты для размышлений:

^ Из первоначального исследования я обнаружил, что мне нужно ввести какой-то каталог Python в эти поля, но я не уверен, что конкретно нужно туда вводить.


Чтобы решить проблему, я сделал следующее:

  • Удалены дополнительные установки / экземпляры Python вне моей папки ArcGIS10.3.
  • Выполните сброс моей среды, выполнив действия из раздела «Learn Python The Hard Way», указав ему поискать в «Python27 ArcGIS10.3»
  • Используется «Программа восстановления» из приложения установки в основной папке ArcGIS Desktop.

Кажется, что сейчас все стабильно и работает.


PyQt5 - изменения палитры / таблицы стилей приводят к сбою программы с использованием eventFilter

Я пытался имитировать калькулятор Windows, используя PyQt5. Я достиг точки, когда мне нужно было изменить цвет текста в QLabel, который я использую в качестве настраиваемой границы окна (чтобы разрешить такие вещи, как прозрачность).

Я начал экспериментировать с такими вещами, как QEvent и eventFilter, и использовать такие методы, как isActiveWindow, чтобы попытаться переключаться между оттенками черного и между прозрачным цветом и непрозрачным.

При этом мне удалось достичь стадии, когда фон полностью меняется, но в тот момент, когда я пытаюсь добавить QLabel / Text в микс, программа вылетает в различных точках. На момент написания статьи я не мог понять, где и почему, а с помощью консоли просто выводится сообщение «Процесс завершен с кодом выхода -1073740791 (0xC0000409)».

Кроме того, я не смог найти ничего очевидного, исходя из моих текущих знаний и опыта, почему это происходит. Пока что YouTube, Google и существующий контент StackOverflow меня подводили. :(

Пожалуйста, примите во внимание, что я новичок в программировании, Python и тем более PyQt5.


Если имя файла контролируется пользователем, вы можете открыть для себя уязвимости (например, злоумышленник может попытаться прочитать файлы конфигурации с паролем базы данных). Но простое открытие дескриптора загруженного файла мало что дает.

Возможно, если базовый механизм попытается прочитать весь файл для целей буферизации, он может заполнить оперативную память и привести к сбою процесса, но Python этого не делает: чтобы прочитать весь файл, вам сначала нужно будет вызвать f.read ( ) - но это именно то, что вы делаете с ним, а не открываете файл. Только открытие файла безвредно.

Операционные системы обычно имеют ограниченное количество файлов, которые они могут открыть одновременно (в частности, ограниченное количество файловых дескрипторов или файловых дескрипторов в Unix-подобных системах или HANDLE в Windows). Если вы разрешите людям открывать произвольное количество из них, не закрывая их, то можно будет исчерпать этот лимит, что помешает ОС открывать больше файлов и, вероятно, приведет к неправильному поведению или даже сбою. Однако было бы трудно использовать его для чего-либо, кроме отказа в обслуживании. Кроме того, программы могут иметь квоты (ниже, чем системный предел) на количество файлов, которые они могут открывать, поэтому одна некорректно работающая программа не может сделать слишком много, и все файлы процесса освобождаются, когда процесс завершается, поэтому обычно это легко достаточно для восстановления работоспособности (действительно, большинство программ вскоре вылетали бы из строя).

Тем не менее, если вы позволяете людям сообщать вашему серверу об открытии файла, было бы неплохо установить ограничение на количество открываемых одновременно файлов и закрыть файл (автоматически, если пользователь не проинструктирует его. случиться первым) через как можно более короткий промежуток времени.

Другой риск может заключаться в открытии сетевых подключений, в зависимости от того, на какой ОС вы работаете и какие типы путей она принимает. Например, если система принимает пути в сетевом стиле Windows ( server share path to file) или SMB (сетевой протокол Windows, реализованный на Unix-подобных в наборе инструментов Samba) пути (smb: // server / share / path) или другие способы доступа к любой сетевой файловой системе, которая еще не смонтирована (или "сопоставлена", если использовать старый термин Windows), с локальной файловой системой, что может привести к тому, что ваш сервер откроет сетевое соединение. в ящик злоумышленника и, возможно, попытайтесь аутентифицироваться. Это может раскрыть информацию о сервере и дать злоумышленникам возможность попытаться скомпрометировать сервер с помощью злонамеренных ответов.

Таким образом, вы также должны ограничить имена файлов тем, что, как вы действительно можете быть уверены, не являются удаленными путями. В общем, вам, вероятно, следует вообще избегать указания путей, просто разрешайте только имена файлов. Однако это единственные два риска, о которых я могу думать. В остальном это довольно безопасно.


Код VS вызывает случайное и полное зависание 17.10, 18.04

Пожалуйста, прочитайте: См. Последний бит. Я не верю, что это проблема Ubuntu, а скорее VS Code.

Недавно под 17.10 и 18.04 (я только что обновился сегодня), Ubuntu случайным образом полностью зависнет. Я не могу перемещать курсор или пользоваться клавиатурой. Естественно, я безуспешно пытался переключиться на сеанс TTY. Каждый раз я должен прибегать к SysRq + R E I S U B, что (очевидно) не является предпочтительным.

Я попытался переключить графические драйверы, исходя из теории, что это может быть так. Изначально я использовал драйвер nVidia с открытым исходным кодом, но безрезультатно перешел на проприетарный. В настоящее время я использую драйвер с открытым исходным кодом.

Все, что у меня обычно открыто, - это Firefox (а не тонна вкладок загружен) и VS Code, максимум с парой файлов и открытым терминалом.

Обновление: системные журналы не показывают что-нибудь вообще что-то происходит, не говоря уже о том, что что-то не так. Я не знаю, связано ли это, но иногда (и особенно после загрузки) программы занимают значительное время (> 5-10 секунд), даже программы командной строки.

Очередное обновление! - Даже при отключенных расширениях GNOME он все равно падал. Я попробовал XFCE, но он все равно вылетел.

Резюме: Ubuntu полностью зависает в кажущееся случайное время, не оставляя следов в журналах, и не имеет отношения к какой-либо конкретной среде рабочего стола или расширениям GNOME.

(вероятно, последнее) обновление: я убежден, что это проблема с VS Code. Я использую GNOME несколько дней с открытыми другими приложениями Electron (Slack, Pulse и т. Д.), И у меня не было ни одного зависания. У меня есть DM'd VS Code в Twitter, и я, скорее всего, отправлю отчет об ошибке, поскольку они еще не ответили.


Ответы участников дискуссии:

Тайлер Гакштаттер

Что-нибудь, связанное с Python, вызывает сбой ArcGIS for Desktop? - Географические информационные системы

TSTL: язык тестирования сценариев шаблонов

TSTL - это предметно-ориентированный язык (DSL) и набор инструментов для поддержки автоматического создания тестов для программного обеспечения. Эта реализация нацелена на Python. Вы определяете (в Python) набор компонентов, используемых для создания теста, и любые свойства, которые вы хотите сохранить для тестируемой системы, а TSTL генерирует тесты для вашей системы. TSTL поддерживает воспроизведение тестов, сокращение количества тестов и анализ покрытия кода, а также включает поддержку кнопок для некоторых сложных методов генерации тестов. Другими словами, TSTL - это имущественное тестирование орудие труда.

Что такое тестирование на основе собственности? Тестирование на основе свойств - это тестирование, которое полагается не на то, что разработчики определяют результаты для конкретных входных данных или последовательностей вызовов, а на более общую спецификацию поведения в сочетании с автоматическим генерированием множества тестов, чтобы убедиться, что общая спецификация выполняется. Подробнее о тестировании на основе свойств см.

https://github.com/trailofbits/deepstate (инструмент, сочетающий символьный анализ и фаззинг с тестированием на основе свойств, для C и C ++, с дизайном, отчасти проинформированным TSTL)

Вы можете легко получить последний tstl-файл с помощью pip. pip install tstl должен работать нормально. Если вы хотите что-то еще более свежее, вы можете сделать:

Для покрытия кода вам также необходимо будет установить инструмент Ned Batchelder cover.py pip install - это все, что необходимо.

Чтобы понять, как работает TSTL, давайте попробуем игрушечный пример. Мы будем использовать TSTL для решения простой «головоломки», чтобы увидеть, можно ли сгенерировать целочисленное значение 510, используя всего несколько строк кода Python, используя только небольшой набор операций (добавить 4, вычесть 3, умножить на 3, и производят степень двойки), начиная с 0.

Как и в обычном Python, # обозначает комментарий. Строки комментариев находятся под описываемым кодом TSTL.

Он должен за несколько секунд найти способ нарушить свойство (получить значение 510), найти максимально простую версию этого «неуспешного теста» и создать файл nuthell.test, содержащий тест. Если бы мы не указали TSTL либо нашел бы способ произвести 510, либо (что менее вероятно) нашел бы способ вызвать переполнение в вызове pow: любой из них будет считаться неудачным.

Это воспроизведет только что созданный тест.

Основная идея TSTL состоит в том, чтобы определить набор возможных шагов в тесте, а также свойства, описывающие, что можно считать неудачным тестом, и позволить TSTL выяснить, существует ли последовательность действий, которая приведет к провалу теста. Действиями могут быть вызовы функций или методов, шаги, которые собирают входные данные (например, создание строки для передачи парсеру), или, действительно, все, что вы можете делать с Python.

TSTL устанавливает несколько стандартных инструментов: сам компилятор TSTL, tstl - генератор случайных тестов, tstl_rt - инструмент для создания автономных тестов, tstl_standalone - инструмент для воспроизведения тестовых файлов TSTL, tstl_replay - инструмент для дельта-отладки и нормализации тестов TSTL, tstl_reduce и инструмент для запуска набора тестов как регрессии, tstl_regress.

Вы можете сделать большую часть того, что вам нужно, с помощью только команд tstl, tstl_rt, tstl_replay и tstl_reduce.

  • tstl & ltfilename.tstl & gt компилирует файл .tstl в интерфейс sut.py для тестирования
  • tstl_rt запускает случайное тестирование на sut.py в текущем каталоге и сбрасывает все обнаруженные ошибки в файлы .test
  • tstl_replay & ltfilename.test & gt запускает сохраненный тест TSTL и сообщает вам, прошел он или не прошел с помощью --verbose, он предоставляет довольно подробную трассировку выполнения теста
  • tstl_reduce & ltfilename.test & gt & ltnewfilename.tstl & gt принимает & ltfilename.test & gt выполняет сокращение и нормализацию, чтобы создать более короткий и понятный тест, и сохраняет результат как & ltnewfilename.tstl & gt.

Все эти инструменты предлагают большое количество параметров конфигурации - help создаст список поддерживаемых параметров для всех инструментов TSTL.

Самый простой способ понять TSTL - это изучить examples / AVL / avlnew.tstl (https://github.com/agroce/tstl/blob/master/examples/AVL/avlnew.tstl), который представляет собой простой пример файла в последний языковой формат.

avlnew.tstl создает довольно полнофункциональный тестер для класса дерева AVL. Однако вы можете написать что-то очень быстрое и довольно эффективное с помощью всего нескольких строк кода:

Это говорит о том, что есть два типа «вещей», задействованных в нашем тестировании реализации AVL-дерева: int и avl. Мы определяем в Python, как создавать эти вещи и что мы можем с ними делать, а затем TSTL создает последовательности действий, то есть тесты, что соответствует нашему определению. TSTL также всегда проверяет, что все деревья AVL правильно сбалансированы. Если бы мы хотели, как в avlnew.tstl, мы также могли бы убедиться, что наше AVL-дерево «действует как» набор --- когда мы что-то вставляем, мы можем найти это, а когда мы что-то удаляем, мы больше не можем найти Это.

Обратите внимание, что мы начинаем с «сырого Python» для импорта модуля avl, SUT. Хотя TSTL поддерживает использование from, псевдонимов и подстановочных знаков при импорте, вы всегда должны импортировать тестируемые модули с помощью простого импорта. Это позволяет TSTL идентифицировать код, который нужно протестировать, и автоматически предоставлять покрытие, методы тестирования на основе статического анализа и надлежащее управление модулями. С другой стороны, служебный код в стандартной библиотеке можно импортировать любым удобным для вас способом.

Если мы проверим это (или avlnew.tstl) в течение 30 секунд, появится что-то вроде этого:

/ tstl / examples / AVL $ tstl_rt --timeout 30

Для многих (но не всех!) Программ более мощной альтернативой простому случайному тестированию является использование роевого тестирования, которое ограничивает действия в каждом отдельном тесте (например, вставлять, но не удалять, или находить, но не обходить порядок) (см. Http : //agroce.github.io/issta12.pdf).

Здесь метод не очень важен, простое случайное тестирование делает достойную работу по покрытию кода дерева AVL всего за 60 секунд. Если мы введем ошибку, удалив вызов self.rebalance () в строке 205 avl.py, любой метод быстро сообщит о неудачном тестовом примере, автоматически уменьшенном. По умолчанию случайный тестер запускает тест в подробном режиме, чтобы более подробно показать, что происходит во время выполнения, которое вызывает сбой.

Используя --output, неудачный тест можно сохранить в названный файл и с помощью утилиты standalone.py преобразовать в полностью автономный тестовый пример, не требующий самого TSTL. Без --output тест все равно сохраняется, но имя основано на идентификаторе процесса tstl_rt. В любом случае вы можете легко повторно запустить сохраненный тест, даже без преобразования в автономный тест, используя tstl_replay & lttestname & gt, и уменьшить его, используя tstl_reduce. Флаг --verbose полезен для воспроизведения, так как он показывает вам, что именно происходит во время теста.

Последний полезный совет для начала: иногда вы можете захотеть протестировать что-то (например, библиотеку, реализованную на C), где неудачные тесты приводят к сбою интерпретатора Python. Это возможно, но требует определенных усилий. Сначала запустите tstl_rt с параметром --replayable. Это заставляет генератор сохранять файл currtest.test в каталоге, в котором вы запускаете тестирование: этот файл содержит текущий тест. Если случайный тестер выйдет из строя, это будет включать действие, вызвавшее сбой. В некоторых редких случаях поведение прошлых тестов также имеет отношение к сбою (перезагрузка модуля на самом деле не сбрасывает состояние системы - например, взаимодействие с оборудованием). В этих случаях используйте --total и просмотрите файл fulltest.test, который содержит ВСЕ действия, когда-либо выполнявшиеся случайным тестером.

Файлы currtest.test и fulltest.test работают так же, как обычные файлы TSTL, и могут быть воспроизведены с помощью утилиты воспроизведения или превращены в отдельные файлы. Однако для правильной работы сокращения и нормализации теста их необходимо уменьшить, передав аргумент --sandbox в tstl_reduce.

А как насчет тестов, которые терпят неудачу при входе в бесконечный цикл? Тот же метод, что и при сбоях, работает. Однако вам нужно запустить tstl_rt с ограничением по времени (например, используя ulimit, если вы работаете в UNIX-подобных системах). Утилита tstl_reduce предоставляет аргумент --timeout для обработки таких тестов, но пока это работает только в системах, поддерживающих ulimit. В очень редких случаях может возникнуть блокировка выполнения теста, потому что, например, сбой вызывает чтение из стандартного ввода. Если вы попадете сюда, свяжитесь со мной.

Наконец, как интегрировать тестирование TSTL с более традиционными подходами, например, pytest? Файл test_tstl_regressions.py в каталоге примеров показывает один способ. Если вы добавите все интересующие вас тесты TSTL в каталог tstl_tests в каталоге, в котором находится sut.py, вы можете заставить pytest запускать все ваши тесты TSTL. Возможно, что более интересно, этот файл также включает в себя простой вызывающий объект, который заставляет pytest выполнять 60 секунд случайного тестирования в качестве проверки работоспособности. Вы можете легко настроить конфигурацию случайного тестирования - часто добавление «--swarm» является хорошей идеей.

TSTL и тестирование мутаций

Используя инструмент universalmutator, вы можете легко исследовать возможности ваших тестовых программ TSTL для поиска ошибок. Например, если бы мы хотели увидеть, насколько эффективны 10 секунд случайного тестирования с использованием нашего инструментария AVL, мы могли бы сделать это:

Это сообщает оценку для мутантов, которые даже не охватываются нашим тестированием, что может не представлять большого интереса, если мы нацелены только на часть API. И, честно говоря, есть более простые способы увидеть, какой код не покрыт, чем использование мутационного тестирования! Поэтому мы можем захотеть ограничить наш анализ кодом, фактически охватываемым жгутом AVL, используя очень большой тайм-аут:

Иногда просто выполнить tstl_rt или даже tstl_rt --swarm недостаточно. Есть и другие варианты улучшения тестирования. Во многих случаях особенно эффективным является использование размера функций в виде строк кода для руководства тестированием. Для этого сначала вы позволяете TSTL определять размеры:

tstl_rt --generateLOC sut.loc --timeout 120

Затем вы используете этот сгенерированный файл для руководства тестированием:

Также для более быстрого тестирования (поскольку сила случайного тестирования частично заключается в генерации огромного количества тестов каждую минуту) отключить сбор покрытия кода с помощью --noCover. Это не так уж и здорово, если вы хотите увидеть, хорошо ли ваши тесты охватывают ваш код, но для поиска ошибок с педалированием по металлу это часто правильный путь.

Есть и другие вещи, которые могут улучшить тестирование. Параметр --profileProbs собирает информацию о том, как часто каждое действие в оснастке TSTL выполнялось во время тестирования, и линейно смещает выбор случайного действия в сторону действий, которые выполнялись реже. Это существенно замедляет генерацию тестов в большинстве случаев, но для многих программ (особенно сложных) это также значительно улучшает покрытие кода и обнаружение ошибок, исследуя труднодоступные действия и тратя меньше времени на создание входных данных по сравнению с запуском SUT. . В этих случаях потеря пропускной способности тестирования, вызванная попытками предпринять действия, которые могут быть отключены, гораздо больше, чем компенсируется улучшением качества тестирования. Поскольку оба полагаются на установку вероятностей действий, --profileProbs и --biasLOC, к сожалению, несовместимы.

Для некоторых программ структура файла оснастки замедляет генерацию тестов, а параметр --useDependencies может повысить производительность теста в 2-10 раз. Однако для большинства программ этот параметр замедляет генерацию тестов примерно в два раза.

Поскольку полезность этих опций сильно различается, лучше просто попробовать их. Для --profileProbs вы должны увидеть значительное увеличение покрытия кода, если оно эффективно для вашей задачи тестирования (вероятно, сопровождаемое большим падением количества сгенерированных тестов), а для --useDependencies вы должны увидеть большое увеличение количества выполненных тестов / тестовых операций.

Вы также можете попробовать подход "генетических алгоритмов", основанный на покрытии, который использует тесты "высокого охвата":

tstl_rt --exploit 0.8 --Pmutate 0.5

Добавление --reducePool иногда также улучшает производительность этого метода.

Вы можете настроить параметры эксплойта и изменения, чтобы увидеть, улучшают ли они результаты. Вы даже можете комбинировать предвзятость строк кода или вероятности на основе профиля с подходом эксплойтов и / или тестированием роя. К сожалению, использование --exploit означает, что вы не можете обойтись без --noCover, чтобы избежать накладных расходов на вычисление покрытия кода.

Мы работаем над тем, чтобы заставить TSTL автоматически проводить эксперименты и посоветовать вам лучшую конфигурацию для тестирования данного жгута.

Чтобы получить набор очень быстрых «регрессионных тестов», вы можете запустить tstl_rt в течение длительного времени в хорошей конфигурации с параметром --quickTests и сгенерировать набор очень коротких тестов с высоким покрытием кода.

TSTL поддерживает автоматическую локализацию неисправностей. Если у вас есть привязь, которая обнаруживает ошибку, вы можете получить некоторое представление о природе этой ошибки, выполнив что-то вроде:

Это запустит TSTL в течение часа, сгенерирует несколько неудачных тестовых случаев (если ваша ошибка может быть обнаружена относительно легко за час), а затем сообщит о 20 наиболее вероятных ошибочных операторах и ветвях в тестируемом коде. Часть этого кода может быть задействована в таких вещах, как печать значений утверждения или обработка ошибок для сбоя, но, по нашему опыту, есть большая вероятность, что вы обнаружите ошибочный код в результатах локализации. Фактически, пятиминутного прогона будет достаточно для хорошей локализации, часто, если пяти минут достаточно, чтобы найти вашу ошибку несколько раз. Учтите, что результаты будут намного хуже, если у вас будет более одной ошибки!

Один из способов эффективного использования роевого тестирования - это применить направленное тестирование роя, подход, при котором данные о том, как swarm взаимодействует с покрытием кода, используются для увеличения покрытия редко охватываемых операторов и ветвей.

Для этого запустите начальное тестирование с помощью tstl_rt (в течение часа или более) с параметрами:

Это проверит вашу программу и создаст два интересующих файла. & ltfilename2 & gt будет содержать простой текстовый файл с охватываемыми ветвями и операторами, ранжированными по количеству их обработок. По сути, это упрощенная версия вывода, с которым вы, возможно, знакомы из gcov или других инструментов. Вы можете просмотреть этот файл и найти интересный, но редко используемый код.

Затем возьмите идентификатор (полную строку, включая круглые скобки) интересующего кода и используйте инструмент tstl_directedswarm следующим образом:

tstl_directedswarm & ltfilename1 & gt "& ltcoverage target & gt" & ltprobFile & gt

(& ltfilename1 & gt - это файл, созданный вами при первоначальном запуске роевого тестирования.) Это попытается выяснить, какие действия помогают («запускать») и препятствуют («подавлять») охват целевого кода, и создают файл (probFile) с вероятностями для использования в более целенаправленном тестировании роя. Если инструмент не определяет никаких триггеров или подавителей, попробуйте снова запустить его с параметром --confidence и числом меньше 0,95. Чем ниже требуемая достоверность, тем выше вероятность обнаружения триггеров и подавителей, но тем меньше вероятность их обнаружения. чтобы иметь смысл - вы можете попробовать медленно опускаться, пока не добьетесь определенных результатов. Затем снова запустите тестирование, например:

tstl_rt --swarm --swarmProbs & ltprobFile & gt

Как правило, таким образом вы сможете хорошо покрыть редко освещаемый код. Поскольку закрытие редко охватываемого кода часто открывает интересный новый, невиданный ранее код, вы можете захотеть повторить этот процесс после того, как изучите редко охватываемый код из своего начального запуска. Вы, конечно же, можете хранить статистику охвата роя и полную статистику покрытия для целенаправленных прогонов TSTL и продолжать изучение.

Более систематический способ проведения направленного тестирования роя - это попробовать:

tstl_analyzeswarm & ltfilename1 & gt & ltprefix & gt --cutoff 0.5

для создания триггеров и подавителей для ВСЕХ целей покрытия, пораженных во время выполнения, сгруппированных в классы эквивалентности (цели с одинаковым набором триггеров и подавителей) и ранжированных по наименее пораженной цели в каждом классе эквивалентности. Вывод будет сохранен в файлах, начинающихся с & ltprefix & gt: набор файлов с именем & ltprefix & gt.N.probs, которые можно использовать с --swarmProbs, и один файл .class со всеми целями, триггерами, подавителями и минимальными частотами для классов. , плюс указатели на соответствующие файлы вероятностей. Простая итерация по сгенерированным файлам вероятностей для классов для самых редких целей - хороший способ провести направленное тестирование роя. Вышеуказанное значение 0,5 может быть любым порогом, выше которого цели, пораженные хотя бы этой частью тестов, считаются хорошо протестированными и игнорируются. Установка этого низкого значения на 0,01 может хорошо работать для начальных запусков, производящих большое количество тестов.

TSTL и американский фаззер Fuzzy Lop (AFL)

Вы даже можете использовать AFL (http://lcamtuf.coredump.cx/afl/) для создания тестов TSTL. Вам необходимо установить сам AFL и пакет python-afl pip (или получить код с github по адресу https://github.com/jwilk/python-afl). Затем вы можете провести фаззинг с помощью AFL в любом каталоге со скомпилированным жгутом TSTL:

tstl_afl_fuzz --output & ltoutputdir & gt --input & ltinputdir & gt

При этом будут использоваться некоторые (обычно хорошие) настройки по умолчанию, чтобы сначала TSTL сгенерировал несколько хороших стартовых тестов для AFL, а затем запустить AFL в течение дня на SUT. Дня может не хватить, поэтому поддерживается тот же параметр --timeout, что и тестером случайной выборки TSTL. Вы также можете использовать тестирование роя, добавив --swarm. Есть и другие, менее часто используемые варианты. Неудачные тесты, созданные AFL, будут сохранены как aflfail. & LtPID & gt.test в текущем каталоге. Один совет: & ltoutputdir & gt, вероятно, должен быть ramdisk, если только вы не хотите по-настоящему забить свой SSD (даже не думайте делать это на реальном жестком диске).

Вы также должны попробовать параметр --persist для tstl_afl_fuzz, который часто значительно улучшает скорость фаззинга и значительно улучшает результаты AFL (поскольку пропускная способность настолько критична), однако это несколько менее хорошо протестировано, чем непостоянный режим. . При дополнительном тестировании это, вероятно, станет настройкой по умолчанию, поэтому вы можете опередить кривую и запускать непостоянный режим только в том случае, если постоянный режим вызывает проблемы.

Это эффективный вариант тестирования, так как он позволяет вам использовать отличную эвристику AFL для фазирования вещей, которые в лучшем случае крайне неудобны при использовании только AFL. Вы можете настроить сложные свойства TSTL, смешивать генерацию грамматики и последовательности вызовов API, а также выполнять дифференциальное тестирование в стиле TSTL, но использовать настроенные методы генерации ввода AFL. Главный недостаток заключается в том, что AFL действительно ожидает гораздо более быстрых исполняемых файлов, чем дает ему TSTL, поэтому вам, вероятно, придется работать несколько дней, чтобы улучшить то, что TSTL может сделать за час, если только ваша SUT не является необычной. Но это, безусловно, привлекательный вариант для недельного тяжелого тестирования, когда tstl_rt не обнаруживает никаких проблем.

Обратите внимание: если вы не используете tstl_afl_fuzz, а напрямую вызываете py-afl-fuzz, вам, вероятно, (кроме Mac OS, где ограничение памяти все равно не работает) понадобится большой -m для работы TSTL.

Под капотом команда tstl_afl принимает файл байтов и интерпретирует каждые N байтов (N зависит от того, сколько действий имеет ваша привязь) как индекс действия TSTL (по модулю количества действий), используя sut.py как обычно. Когда tstl_afl обнаруживает сбой, он также создает обычный тестовый файл TSTL под именем aflfail. & LtPID & gt.test. Вы даже можете использовать --swarm, чтобы интерпретировать первые 4 байта как начальное значение для управления тестированием роя, что позволяет AFL использовать тестирование роя, это имеет недостаток, заключающийся в том, что файл будет неправильно интерпретироваться другими инструментами TSTL, если вы не передадите им - -aflswarm вариант. Большинство инструментов TSTL используют параметр --afl, который указывает, что тесты, которые нужно прочитать, имеют формат AFL, и --aflswarm, чтобы указать, что это тесты роя.

tstl_afl также полезен для превращения одиночного байтового файла AFL в обычный тестовый файл TSTL, используя параметр --alwaysSave, который выгружает тестовый файл TSTL в текущий каталог, созданный из байтовых входных данных.

Существуют также инструменты для преобразования большого количества файлов в формат AFL и обратно. tstl_toafl просто берет существующие тестовые файлы TSTL и преобразует их во входные байты AFL, а tstl_fromafl делает ожидаемое противоположное (и принимает аргумент, указывающий, что файлы находятся в формате swarm). tstl_aflcorpus случайным образом генерирует входные данные, которые запускают новое покрытие SUT для запуска AFL, но обычно проще просто сгенерировать быстрые тесты с помощью tstl_rt --quickTests и преобразовать их с помощью tstl_toafl. tstl_aflcorpus действительно позволяет использовать формат AFL swarm, однако просто запустите его с помощью --swarm. Из-за того, как работает формат роя, в настоящее время, к сожалению, невозможно извлечь тест формата роя из стандартного теста TSTL.

tstl_smallcheck - это специальный генератор тестов, который использует поиск в глубину для исчерпывающей генерации тестов до заданного предела глубины. Инструмент выводит тесты, увеличивающие покрытие, и останавливается, если обнаруживает сбой. Это редко заканчивается, если глубина превышает 3–10 (самое большее) шагов, если только не происходит сбой. Если у вас закончится терпение, вы можете прервать процесс, нажав CTRL-C, и инструмент сохранит обнаруженные тесты.

Один из способов получить более глубокое «исчерпывающее» тестирование - это использовать параметр --recursive для изучения тестов увеличения покрытия, многократно до ограниченного числа раз, используя ту же глубину, что и исходный прогон (и небольшую начальную глубину).

Если вы хотите собрать все неудачные тесты, а не останавливаться на первом, вам нужно использовать параметр --multiple. Из-за своего небольшого размера и предполагаемого стремления к исчерпывающему исследованию (в конце концов, вы использовали этот инструмент), этот инструмент не обеспечивает ни сокращения, ни нормализации покрывающих тестов или отказов, чтобы избежать любого риска проскальзывания.

В дополнение к --recursive вы можете использовать --visited или --visitedList, чтобы избежать повторного посещения уже исследованных состояний во время DFS, однако это требует некоторой осторожности. Если инструмент не работает или тесты не кажутся действительными / правильными, вы можете перекомпилировать ваш жгут с помощью --defaultReplay, потому что обратное отслеживание на основе состояния не работает. Во многих случаях из-за высокой стоимости сравнения состояний в этой настройке отслеживание посещенных состояний может быть даже не очень полезным.

Случайное тестирование с использованием tstl_rt, вероятно, почти всегда более эффективно, чем этот подход, но tstl_smallcheck может предоставить гарантии того, что tstl_rt не может, например, что ни один тест с менее чем четырьмя шагами не может вызвать какие-либо сбои. Запуск небольшой проверки из существующих быстрых тестов с использованием параметра --fromTests - это один из способов повысить уверенность в своем тестировании.

Некоторые из вас могут спросить: «Чем TSTL отличается от гипотезы https://hypothesis.readthedocs.io/en/latest/ инструмента тестирования?» Есть несколько ответов. Во-первых, прямо сейчас TSTL, вероятно, гораздо менее доработан, чем гипотеза! Что еще более важно, и Hypothesis, и TSTL генерируют тесты, но в первую очередь они предназначены для генерации различных видов тестов. Гипотеза - это то, что мы считаем семейством QuickCheck: если у вас есть функция f, которая принимает в качестве входных данных список, строку или что-то более сложное, скорее всего, вы захотите использовать гипотезу. Если у вас есть набор функций f, g и h, и они не просто возвращают вещи, но изменяют невидимое состояние системы (но также возвращают вещи, которые могут быть входными данными для других функций), вам может понадобиться TSTL. Вы можете выполнять тестирование последовательности вызовов методов на основе состояний с помощью Hypothesis, но это может быть проще с TSTL, и это то, для чего TSTL создан. Итак, если вы тестируете реализацию сортировки, Hypothesis почти наверняка намного лучше. Если вы тестируете что-то вроде файловой системы, вы можете изучить TSTL. Если вы тестируете синтаксический анализатор, который принимает строку в качестве входных данных, оба инструмента могут быть полезны в зависимости от вашей ситуации. Еще одно отличие для типичного пользователя заключается в том, что TSTL имеет значительную встроенную поддержку для выполнения дифференциального / эталонного тестирования, когда ваша SUT сравнивается с эталонной реализацией, возможно, с некоторым кодом для обработки ожидаемых различий (см. Пример pyfakefs для хорошего внешнего вида. насколько мощным это может быть). Наконец, TSTL создан как практический инструмент тестирования, но на дизайн сильно повлияло решение сделать его полезным в качестве платформы для экспериментов с новыми алгоритмами тестирования программного обеспечения.

Сходство в том, что и TSTL, и Hypothesis не похожи на традиционное модульное тестирование. They instead let you define the idea of a valid input (either some data values, or in TSTL a sequence of method calls and assignments that more resembles a traditional do-some-stuff-and-then-check-it unit test) and assert general properties about the behavior of a system under valid input.

Tips for Handling Numerous Bugs

If you test real software with a good harness, you may well find many issues. There are a few ways to deal with this. First, using --normalize when doing --multiple runs with tstl_rt can help. In some cases (file systems) normalization (or even reduction) goes too far. In testing at NASA, we found that "last operation" was a good heuristic for different bugs. Using --keepLast in testing (or when using tstl_reduce ) forces reduction and normalization to leave the last step alone. Normalization can still move it around, or change the pool it uses, but is much more careful about changing the actual action performed. There is also a tool tstl_triage that takes a glob expression for a set of tests, runs them all, and reports ones with different (heuristic) failure signatures. In particular, it gives you the shortest test for each signature. Remember that triage requires a glob expression (in quotes) not a list of files. This is so it can handle even sets of tests that go beyond the shell expansion limit. We assume that you won't need to handle that many tests in regression, but for triage, who knows? Another tool, tstl_fpf takes similar arguments to tstl_triage but instead of clustering tests into groups that are likely the same bug, it ranks all tests, such that very different tests are high in the ranking, using the "furthest-point-first" (FPF) method proposed by Chen et. al in PLDI 2013.

For more details on TSTL, the best starting point is a comprehensive journal paper in STTT: http://agroce.github.io/sttt17.pdf. There are also NASA Formal Methods (NFM) and International Symposium on Software Testing and Analysis (ISSTA) 2015 papers at http://agroce.github.io/nfm15.pdf and http://agroce.github.io/issta15.pdf, with some implementation details or concepts that are not present in the more up-to-date and complete paper. In particular, the NFM paper, "A Little* Language for Testing" has a deprecated syntax and other issues, but is the most concise explanation of the core TSTL idea: a DSL embedding a full programming language, designed to make testing (and building testing tools) easy.

There is a more recent paper describing test normalization, a feature unique to TSTL, in more detail, http://agroce.github.io/issta17.pdf, as well as a tool paper describing how to use TSTL's test manipulation commands (http://agroce.github.io/issta17tool.pdf).

The NFM and ISSTA papers use an early version of TSTL syntax, which marks pools and TSTL constructs with % signs. "Modern" TSTL uses <> by default, though if for some reason you need <> in your code (and to prepare for a future C++ version) this can be turned off and only % supported.

Note that documentation above is preliminary. The best way to get started, once you understand the basic tools ( tstl , tstl_rt , tstl_replay , and tstl_reduce ) is to examine the examples directory and try out real TSTL test harnesses. For the brave, reading tstl/randomtester.py provides considerable guidance in how to (efficiently) use TSTL in a generic testing tool, with TSTL providing an interface to the underlying application/library to be tested.

Note that TSTL was originally written for Python 2.7, has mostly been developed/tested that way, and is not extremely well-tested yet with Python 3.0+. However, it should work ok, thanks to mrbean-bremen, and the Travis tests check that TSTL works fine on Python 3.6. Earlier 3.0+ versions may have some "gotchas."

There are no developer docs yet, which will hopefully change in the future. The best shakedown test for tstl is to compile and run (using tstl_rt ) the AVL example. Removing any call to the balancing function in the avl.py code should cause TSTL to produce a failing test case.

Who is responsible for TSTL?

Alex Groce (agroce) wrote this file, and most of the current code base, and is running the show. If there is a problem with TSTL, it is my fault, and don't blame anyone below.

Josie Holmes (josieholmes) contributed to core language design changes, and is responsible for the ideas (and some of the code) for the various slippage reduction strategies, plus the LOC bias work and Markov things. Before Josie's work, TSTL was extremely hard to read, and considerably less efficient.

Jervis Pinto was the other original TSTL-er, and has his fingerprints on various parts of the early design and code that form the foundations of TSTL.

Pranjal Mittal contributed a number of critical elements, including the initial effort to prepare TSTL for a pip release as a useful tool, and has helped publicize TSTL.

Pooria Azimi added the <int,1> notation, which turns out to be one of the most important changes, and eliminated the need for the exceedingly awkward way of handling binding via Python functions and commit point based guards. Without this, you really don't have a useful TSTL.

Kevin Kellar developed a (beta) Java version of TSTL: https://github.com/flipturnapps/TSTL-Java.

My (Alex's) other graduate students (Amin Alipour, Rahul Gopinath, Arpit Christi, Chaoqiang Zhang, Shalini Shamasunder) and almost-mine graduate student (Iftekhar Ahmed) contributed to the general intellectual climate in which TSTL was born.

Students in CS 499 at Northern Arizona University and CS 362, 562, and 569 at Oregon State University contributed a lot of ideas, and a few concrete language/tool changes or bug reports. These are too numerous to mention, and in some cases I don't recall who asked "why do you do it that stupid way?" in class, and got me thinking that it was in fact a stupid way to do things.

Ned Batchelder, David R. MacIver, and John Regehr have no actual code in TSTL, but all contributed in significant ways to various implementation aspects, in ways that go beyond the general disclaimer that TSTL freely steals from the entire software testing (research) community.

The pyfakefs team (mrbean-bremen and jmcgeheeiv on github) really worked with me to test pyfakefs, which resulted in a number of nice improvements to TSTL and to differential testing in particular. More recently, mrbean-bremen has taken the lead in making TSTL compatible with Python 3, which seems to mostly be done now!

Jakub Wilk helped with modifications to python-afl that made TSTL/AFL integration work much better.

Corey Kosak helped turn this README into something that you might actually enjoy reading, and gets to the point much faster than previous versions.

* Do you actually remember that asterisk way up there? The footnote is that TSTL является a little language. However, in another sense, it embeds all of Python which makes it pretty big. It depends on how you think about it.


My Pi keeps crashing — where should I look?

I know my problem is too vague to solve the root problem. Please help me on my way.

My problem
I have a Pi setup with owncloud. And a external hard drive with videos on it.
It just functions as a NAS. I use SFTP for all my connections.
But it (seemingly) crashes at random. It crashed last night when it was idling, and does so a few times a week. Pulling the plug and reinserting it creates a successful reboot.

  • It's a Pi 2 Model B.
  • I tried 2 different power supplies for the Pi. Neither had problems with an older Pi model.
  • The external drive is externally powered.
  • I run the Pi headless.
  • When it crashes I can't login or reach it in any way. The power LED is lit.

My question:

  • Where should I look to narrow this down?
  • What might I do the log this behaviour?
  • Where is a place to get more specific support for this kind of broad, vague problems?

What helped so far

A comment made by Goldilocks to determine the difference if it really crashes or I just can log in.


As stuff is stored into, left, and eventually pulled out of RAM, some corruption naturally occurs (theories vary, but the one with the most weight right now is EMI from the computer itself). ECC is a feature of RAM and motherboards that allows detection and correction of this corruption.

The corruption is usually pretty minor (ECC can usually detect and fix 1-2 bits per 64 bit "word" - and that's waaaaay beyond the typical error rates), but increases in frequency with the density of the RAM. Your average workstation/PC will never notice it. On a server where you're running high density RAM 24/7 in a high-demand environment serving critical services, you take every step you possibly can to prevent stuff from breaking.

Also note that ECC RAM must be supported by your motherboard, and the average workstation/PC does not support it.

ECC RAM is more expensive than non-ECC, is much more sensitive to clock speeds, and can incur a small (1-2%) performance hit. If it helps, an analogy that works is RAM to RAID controllers. On your PC, that hardware-assisted software RAID built into your chipset is great protection against single disk failures. On a server, that would never be enough. You need high-end, battery-backed fully hardware RAID with onboard RAM to ensure that you don't lose data due to a power outage, disk failure, or whatever.

So no, you don't really need ECC RAM in your workstation. The benefit simply will not justify the price.

10% you'd expect from the additional chip area, for the same usable amount of RAM). It might be worth revisiting particularly the last sentence in light of this. &ndash user Oct 18 '15 at 13:07

If this article is anything to go by, then you should use ECC RAM.

It's not just a matter of "I don't run a server, so I don't need it". It depends how much you value your data. It's not just a matter of occasional crashes - the problem is you could get corruption and have no way of knowing that it's going on.

ECC RAM gets more interesting as memory sizes grow. The probability of a single bit error in a machine with 8GB of RAM is quite a lot higher than it was in the days of a 640K PC/XT, simply due to the larger number of bits. On a database server where that RAM might be in a disk buffer, a bit error can corrupt disk storage as well. Generally you would expect to use ECC memory on a server.

Some workstations (particularly those with Xeon or Opteron CPUs) take registered memory, which pretty much only comes in ECC flavours anyway. On a desktop PC you may view it as overkill.

ECC RAM is designed to aid in preventing and fixing memory based errors, usually using some sort of hamming code or modular redundancy. This is very useful in servers that contained important data, or need high availability, but it comes at a cost.

Whilst its probably worth paying the extra for your important servers, do you really want to do so for your desktop machine, does it matter if there is the occasionally memory error? Sure it matters if your SQL database drops some data during a transaction, but do you care if your word document is affected by a slight memory blip?

If you want a надежный workstation then you want ECC RAM for it. It will crash less often and work done on it and documents cached in RAM will not be randomly corrupted.

An additional benefit of ECC over what was mentioned above is that you can detect bad RAM. While running a long memtest86 session will usually find any problems, there may be very specific problems with the RAM which only show up rarely and in certain use cases. This can still happen much more frequently than the corruption that perfectly good ECC RAM is designed to protect against -- maybe once every month. So if you install monitoring software, you can be sure that your RAM is good, or replace bad chips. Still a marginal benefit, but as ECC memory is not much more expensive than normal RAM, it may be worth it.

ECC memory now costs about the same as non-ECC memory, as prices have dropped. So check prices if prices are anywhere close, buy ECC if your workstation accommodates it.

I think there may be some confusion just based on the title of the question.

If you just mean the average desktop PC, then that is usually based on a platform that doesn't even have ECC support.

If you mean a workstation class computer, then it quite likely comes with ECC memory whether you care about it or not.
Overall, the workstation class is typically based on essentially server hardware but with proper graphics and packaged in a different form-factor.

The expected workload is also more taxing than that of the desktop PC, so if you acknowledge that ECC makes sense for servers, then I think it's not much of a stretch that ECC also makes sense for workstations.

For Desktop PCs, there's some debate whether ECC would make sense or not. It can absolutely be argued that everything ought to have ECC but, right now, it's not practical as the industry has decided to make ECC a feature to differentiate higher end hardware.

According to the article Zan Lynx linked in the comments: DRAM Errors in the Wild: A Large-Scale Field Study, the uncorrectable errors are common while random correctable errors appear rarely in a system. The incidence is probably a few in a year, but it depends on the usage.

So in a server environment the correctable errors might not be that important, but you boot the server machines rarely, so uncorrectable errors caused by failing RAM can be there undetected for a while corrupting your data. I think that's the main reason why servers need ECC. Workstations boot and so check RAM frequently, so hardware failures can be detected by every reboot. If that frequency is sufficient for your business, then I think you won't need ECC RAM in your workstation.

If we are talking about memory errors, it is better to version the important documents on the server. So if the workstation reads and modifies something, then the original content should not be overwritten on the server. Regular backups can do the same for you.

Another aspect of this question is security. If your workstation is connected to any non-safe network, then it might be vulnerable to the row hammer attack, which exploits a DRAM related phenomenon. So from security perspective it is better to use ECC RAM.

I would use ECC everywhere, always, and I'm upset and disappointed I cannot get it on my MacBook Pro laptop, because otherwise it could completely replace my desktop server. In my desktop server, over 10 years I have had to replace 2 memory sticks due to persistent errors which would have just been random crashes and data corruption if it were not for ECC detecting and correcting them. Not counting all the errors in those failed sticks, I would estimate seeing about 8 errors per year. Of course, this is a tiny sample and anecdotal evidence a much better resource is Google's study which showed that about 1/3 of their servers experienced at least one memory error in a given year.

I agree with Linus Torvalds (creator of Linux) that the real driving force behind keeping ECC unavailable is Intel:

Torvalds takes the bold position that the lack of ECC RAM in consumer technology is Intel's fault due to the company's policy of artificial market segmentation. Intel has a vested interest in pushing deeper-pocketed businesses toward its more expensive—and profitable—server-grade CPUs rather than letting those entities effectively use the necessarily lower-margin consumer parts.

Removing support for ECC RAM from CPUs that aren't targeted directly at the server world is one of the ways Intel has kept those markets strongly segmented. Torvalds' argument here is that Intel's refusal to support ECC RAM in its consumer-targeted parts—along with its de facto near-monopoly in that space—is the real reason that ECC is nearly unavailable outside the server space.


StackTracker - Cross-platform desktop notification app

The application displays a task tray notification when someone has posted an answer or a comment to a question you are tracking on any of the StackExchange sites. Clicking the notification will open the corresponding question in your browser.

License

GPL - Full LICENSE file available in the repo (below)

Download

Linux build: Download Linux ZIP (Requires Python 2.6 and PyQt4 to be installed)

Run >> python StackTracker.py from the StackTracker folder

Windows build: Download Windows ZIP (May need Microsoft VC++ DLL installed)

Launch the StackTracker.exe .

Mac OS X build: Download Mac OS X tarball (Requires Growl to be installed)

Launch StackTracker.app . Only tested in Leopard/Snow Leopard on Intel-based Macs.


kill -9 (SIGKILL) always works, provided you have the permission to kill the process. Basically either the process must be started by you and not be setuid or setgid, or you must be root. There is one exception: even root cannot send a fatal signal to PID 1 (the init process).

However kill -9 is not guaranteed to work немедленно. All signals, including SIGKILL, are delivered asynchronously: the kernel may take its time to deliver them. Usually, delivering a signal takes at most a few microseconds, just the time it takes for the target to get a time slice. However, if the target has blocked the signal, the signal will be queued until the target unblocks it.

Normally, processes cannot block SIGKILL. But kernel code can, and processes execute kernel code when they call system calls. Kernel code blocks all signals when interrupting the system call would result in a badly formed data structure somewhere in the kernel, or more generally in some kernel invariant being violated. So if (due to a bug or misdesign) a system call blocks indefinitely, there may effectively be no way to kill the process. (But the process буду be killed if it ever completes the system call.)

A process blocked in a system call is in uninterruptible sleep. The ps or top command will (on most unices) show it in state D (originally for “disk”, I think).

A classical case of long uninterruptible sleep is processes accessing files over NFS when the server is not responding modern implementations tend not to impose uninterruptible sleep (e.g. under Linux, the intr mount option allows a signal to interrupt NFS file accesses).

If a process remains in uninterruptible sleep for a long time, you can get information about what it's doing by attaching a debugger to it, by running a diagnostic tool such as strace or dtrace (or similar tools, depending on your unix flavor), or with other diagnostic mechanisms such as /proc/PID/syscall under Linux. See Can't kill wget process with `kill -9` for more discussion of how to investigate a process in uninterruptible sleep.

You may sometimes see entries marked Z (or H under Linux, I don't know what the distinction is) in the ps or top output. These are technically not processes, they are zombie processes, which are nothing more than an entry in the process table, kept around so that the parent process can be notified of the death of its child. They will go away when the parent process pays attention (or dies).


Смотреть видео: What should I do for my GIS project? Full Video (September 2021).