Прикреплённый файл «Merzavets.html»

мерзавец - делит пополам (1) Ручная Страница

РЕЗЮМЕ

мерзавец делит пополам <подкомандуют> <варианты>

ОПИСАНИЕ

Команда берет различные подкоманды, и различные варианты в зависимости от подкоманды:

мерзавец делит пополам помощь 

мерзавец делит пополам начало [<плохо> [<хороший>...]] [-] [<пути>...] 

мерзавец делит пополам, плохо [<газуют>] 

мерзавец делит пополам хороший [<преподобный>...] 

мерзавец делит пополам пропуск [(<преподобный> | <диапазон>)...] 

мерзавец делит пополам сброс [<передают>] 

мерзавец делит пополам, визуализируют 

мерзавец делит пополам переигровку <logfile> 

мерзавец делит пополам регистрацию 

мерзавец делит пополам управляемый <cmd>...

Эта команда использует список преподобного мерзавца - делят пополам, чтобы помочь заставить процесс двоичного поиска находить, какое изменение представило ошибку, учитывая старую "пользу" передают название объекта, и более позднее "плохое" передают название объекта.

Получение помощи

Использование "мерзавец делит пополам", чтобы получить короткое описание использования, и "мерзавец делит пополам помощь", или "мерзавец делит пополам-h", чтобы получить длинное описание использования.

Основной делят пополам команды: начните, плохой, хороший

Используя ядерное дерево Linux как пример, основное использование разделить пополам команды следующие:

Мерзавец $ делит пополам начало 

Мерзавец $ делит пополам плохо #, Текущая версия плоха 

Мерзавец $ делит пополам хороший v2.6.13-rc2 # v2.6.13-rc2, была последняя версия 

                                 # проверил, который был хорош

Когда Вы определили по крайней мере один плохой и одна хорошая версия, команда делит пополам дерево пересмотра и производит что-то подобное следующему:

Деление пополам: 675 пересмотров уехали, чтобы проверить после этого

Государство в середине набора пересмотров тогда проверено. Вы теперь собрали бы то ядро и загрузили бы его. Если бы обутое ядро работает правильно, Вы тогда выпустили бы следующую команду:

Мерзавец $ делит пополам хороший #, этот хорош

Продукция этой команды была бы чем-то подобным следующему:

Деление пополам: 337 пересмотров уехали, чтобы проверить после этого

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

В конечном счете не будет больше пересмотров, оставленных разделить пополам, и Вас оставят с первым плохим ядерным пересмотром в "refs/bisect/bad".

Разделите пополам сброс

После разделить пополам сессии, чтобы очистить государство деления пополам и возвратиться к оригинальной ГОЛОВЕ, выпускают следующую команду:

Мерзавец $ делит пополам сброс

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

С дополнительным аргументом Вы можете возвратиться к различному, передают вместо этого:

Мерзавец $ делит пополам сброс <передают>

Например, мерзавец делят пополам ГОЛОВУ сброса, уедет, Вы на текущем делении пополам передаете и избегаете переключаться, передает вообще, в то время как мерзавец делит пополам сброс, делят пополам/плохи, проверит первый плохой пересмотр.

Разделите пополам визуализируют

Чтобы видеть в настоящее время остающихся подозреваемых в gitk, выпустите следующую команду во время процесса деления пополам:

Мерзавец $ делит пополам, визуализируют

представление может также использоваться, поскольку синоним для визуализирует.

Если переменная окружения ПОКАЗА не установлена, регистрация мерзавца используется вместо этого. Вы можете также дать параметры командной строки, такие как-p и - stat.

Мерзавец $ делит пополам представление - stat

Разделите пополам регистрацию и разделите пополам переигровку

Отметив пересмотры как хороший или плохой, выпустите следующую команду, чтобы показать то, что до сих пор делалось:

Мерзавец $ делит пополам регистрацию

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

Мерзавец $ делит пополам сброс 

Мерзавец $ делит пополам что-файл переигровки

Уход от тестирования передавания

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

Например:

Мерзавец $ делит пополам хороший/плохой #, предыдущий раунд был хорош или плох. 

Деление пополам: 337 пересмотров уехали, чтобы проверить после этого 

Мерзавец $ делит пополам, визуализируют # ой, который является неинтересным. 

Мерзавец $ перезагружал - трудно, HEAD~3 # пробуют 3 пересмотра перед какой 

                                        # был предложен

Тогда соберите и проверьте выбранный пересмотр, и впоследствии отметьте пересмотр как хороший или плохой в обычной манере.

Разделите пополам пропуск

Вместо того, чтобы выбрать соседним передают, Вы можете попросить, чтобы мерзавец сделал это для Вас, выпуская команду:

Мерзавец $ делит пополам пропуск #, Текущая версия не может быть проверена

Но мерзавец может в конечном счете быть неспособен сказать, что первые плохие передают среди плохого, передают и один, или более пропущенный передает.

Вы можете даже пропустить диапазон, передает, вместо только каждый передает, используя" <commit1>.. <commit2>" примечание. Например:

Мерзавец $ делит пополам пропуск v2.5.. v2.6

Это говорит разделить пополам процесс, которые не передают после v2.5, до и включая v2.6, должны быть проверены.

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

Мерзавец $ делит пополам пропуск v2.5 v2.5.. v2.6

Это говорит разделить пополам процессу, что передавание между включенным v2.5 и включенным v2.6 должно быть пропущено.

Сокращение деления пополам, давая больше параметров, чтобы разделить пополам начало

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

Мерзавец $ делит пополам начало - arch/i386 include/asm-i386

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

Мерзавец $ делит пополам начало v2.6.20-rc6 v2.6.20-rc4 v2.6.20-rc1- 

                   # v2.6.20-rc6 плох 

                   # v2.6.20-rc4 и v2.6.20-rc1 хороши

Разделите пополам управляемый

Если у Вас есть подлинник, который может сказать, хорош ли текущий исходный код или плох, Вы можете разделить пополам, выпуская команду:

Мерзавец $ делит пополам my_script аргументы, которыми управляют,

Отметьте, что подлинник (my_script в вышеупомянутом примере) должен выйти с кодом 0, если текущий исходный код хорош, и выход с кодексом между 1 и 127 (содержащий), кроме 125, если текущий исходный код плох.

Любой другой код завершения прервет разделить пополам процесс. Нужно отметить , что программа, которая заканчивается через "выход (-1)" $листьев? = 255, (см. выход (3) ручная страница), поскольку ценность расколота с "& 0377".

Специальный код завершения 125 должен использоваться, когда текущий исходный код не может быть проверен. Если выходы подлинника с этим кодексом, текущий пересмотр будет пропущен (см., что мерзавец делит пополам пропуск выше). 125 был выбран в качестве самой высокой заметной ценности, чтобы использовать с этой целью, потому что 126 и 127 используются раковинами POSIX, чтобы сигнализировать, определенный ошибочный статус (127 для команды, не найденной, 126 для найденной команды, но не выполнимый---, эти детали не имеют значения, поскольку они - нормальные ошибки в подлиннике, насколько "делят пополам управляемый", затронут).

Вы можете часто находить, что во время разделить пополам сессии хотите иметь временные модификации (например, s/#define, ОТЛАДКА 0/#define ОТЛАЖИВАЕТ 1/в заголовочном файле, или "пересмотр, который не имеет, это передает потребности этот участок, примененный к работе вокруг другой проблемы, это деление пополам не интересуется"), относился к проверяемому пересмотру.

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

ПРИМЕРЫ

Автоматически разделите пополам сломанный, строят между v1.2 и ГОЛОВОЙ:

Мерзавец $ делит пополам ГОЛОВУ начала v1.2 - #, ГОЛОВА больна, v1.2 хорош 

Мерзавец $ делит пополам управляемый, делают #, "делают", строит приложение

Автоматически разделите пополам испытательный отказ между происхождением и ГОЛОВОЙ:

Мерзавец $ делит пополам происхождение ГОЛОВЫ начала - #, ГОЛОВА больна, происхождение хорошо 

Мерзавец $ делит пополам управляемый, делают тест #, "делают тест", строит и проверяет

Автоматически разделите пополам сломанный прецедент:
```
Кошка $ ~/test.sh 

#!/bin/sh 

сделайте ||, выходят 125 #, это пропускает сломанный, строит 

~/check_test_case.sh # прецедент проходит? 

Мерзавец $ делит пополам ГОЛОВУ начала HEAD~10 - #, преступник среди последних 10 

Мерзавец $ делит пополам ~, которым управляют,/test.sh
```
Здесь мы используем "test.sh" таможенный подлинник. В этом подлиннике, если "делают" , терпит неудачу, мы пропускаем поток, передают. "check_test_case.sh" должен "выйти 0", если прецедент проходит, и "выход 1" иначе.

Более безопасно, если и "test.sh" и "check_test_case.sh" вне склада, чтобы предотвратить взаимодействия между тем, чтобы делить пополам, сделайте и проверьте процессы и подлинники.
Автоматически разделите пополам с временными модификациями (горячее затруднительное положение):
```
Кошка $ ~/test.sh 

#!/bin/sh 



# щипают рабочее дерево, сливая отделение горячего затруднительного положения 

# и затем делают попытку строить 

если слияние мерзавца - нет - передает горячее затруднительное положение && 

        сделать 

тогда 

        # проектный определенный тест, которым управляют, и отчет его статус 

        ~/check_test_case.sh 

        $ status=? 

еще 

        # говорят гостю, что это является нетестируемым 

        status=125 

fi 



# уничтожают щипок, чтобы позволить чистое щелкание следующему, передают 

мерзавец перезагружал - трудно 



# возвращают контроль 

выходной $status
```
Это применяет модификации от отделения горячего затруднительного положения перед каждым испытанием, например, в случае, если Ваш строить или условия испытаний изменился так, чтобы более старым пересмотрам, возможно, понадобилось затруднительное положение, которое более новые уже имеют. (Удостоверьтесь , что отделение горячего затруднительного положения базируется от передавания, которое содержится во всех пересмотрах , которые Вы делите пополам, так, чтобы слияние не потянуло в слишком много, или использовало вишневый выбор мерзавца вместо слияния мерзавца.)
Автоматически разделите пополам сломанный прецедент:
```
Мерзавец $ делит пополам ГОЛОВУ начала HEAD~10 - #, преступник среди последних 10 

Мерзавец $ делит пополам sh, которым управляют-c, "делают ||, выходят 125; ~/check_test_case.sh"
```
Это показывает, что Вы можете обойтись без подлинника пробега, если Вы пишете тест на единственной линии.

СМ. ТАКЖЕ

Регрессы борьбы с мерзавцем делят пополам, вина мерзавца (1).