This is an archive of the discontinued LLVM Phabricator instance.

Differential D80408

[lldb/Test] Remove issue_verification subdirectory
ClosedPublic

Authored by JDevlieghere on May 21 2020, 2:41 PM.

Details

Reviewers
labath
clayborg
Group Reviewers
Restricted Project
Commits
rGd89c98a020c9: [lldb/Test] Remove issue_verification subdirectory
Summary

Seems like these files haven't been touched since 2015.

Diff Detail

Event Timeline

JDevlieghere created this revision.May 21 2020, 2:41 PM
labath accepted this revision.May 22 2020, 1:26 AM

Yes, these were intended to be unit tests for the test framework itself. A great idea, but it never really took off. I have never been able to get the initial tests that Todd added to work for me, and most of them are largely irrelevant by now.

This revision is now accepted and ready to land.May 22 2020, 1:26 AM
Closed by commit rGd89c98a020c9: [lldb/Test] Remove issue_verification subdirectory (authored by JDevlieghere). · Explain WhyMay 22 2020, 9:39 AM
This revision was automatically updated to reflect the committed changes.
Herald added a project: Restricted Project. · View Herald TranscriptMay 22 2020, 9:39 AM

Revision Contents

Diff 265759

lldb/test/API/issue_verification/README.txt

  • This file was deleted.
Tests in this directory are intentionally setup to
fail, error, timeout, etc. to verify that the buildbots
pick up errors. The tests in this directory will be
parked/removed/renamed after verifying they trigger
as expected.

lldb/test/API/issue_verification/TestExpectedTimeout.py.park

  • This file was deleted.
"""Tests that a timeout is detected by the testbot."""
from __future__ import print_function
import time
import lldbsuite.test.lldbtest as lldbtest
class ExpectedTimeoutTestCase(lldbtest.TestBase):
"""Forces test timeout."""
mydir = lldbtest.TestBase.compute_mydir(__file__)
@lldbtest.expectedFailureAll()
def test_buildbot_sees_expected_timeout(self):
"""Tests that expected timeout logic kicks in and is picked up."""
while True:
try:
time.sleep(1)
except:
print("ignoring exception during sleep")

lldb/test/API/issue_verification/TestFail.py.park

  • This file was deleted.
"""Tests that a FAIL is detected by the testbot."""
import lldbsuite.test.lldbtest as lldbtest
class FailTestCase(lldbtest.TestBase):
"""Forces test failure."""
mydir = lldbtest.TestBase.compute_mydir(__file__)
def test_buildbot_catches_failure(self):
"""Issues a failing test assertion."""
self.assertTrue(
False,
"This will always fail, buildbot should flag this.")

lldb/test/API/issue_verification/TestInvalidDecorator.py.park

  • This file was deleted.
from lldbsuite.test import lldbtest
from lldbsuite.test import decorators
class NonExistentDecoratorTestCase(lldbtest.TestBase):
mydir = lldbtest.TestBase.compute_mydir(__file__)
@decorators.nonExistentDecorator(bugnumber="yt/1300")
def test(self):
"""Verify non-existent decorators are picked up by test runner."""
pass

lldb/test/API/issue_verification/TestRerunFail.py.park

  • This file was deleted.
"""Tests that a flakey fail is rerun, and will pass on the rerun.
Run this test with --rerun-all-issues specified to test that
the tests fail on the first run, then pass on the second.
Do not mark them as flakey as, at this time, flakey tests will
run twice, thus causing the second run to succeed."""
import rerun_base
import lldbsuite.test.lldbtest as lldbtest
class RerunFailTestCase(rerun_base.RerunBaseTestCase):
"""Forces test failure on first run, success on rerun."""
@lldbtest.no_debug_info_test
def test_buildbot_catches_failure(self):
"""Issues a failing test assertion."""
if self.should_generate_issue():
self.assertTrue(
False,
"This will fail on the first call, succeed on rerun, and "
"alternate thereafter.")

lldb/test/API/issue_verification/TestRerunFileLevelTimeout.py.park

  • This file was deleted.
"""Tests that a timeout is detected by the testbot."""
from __future__ import print_function
import atexit
import time
from lldbsuite.test import decorators
import rerun_base
class RerunTimeoutTestCase(rerun_base.RerunBaseTestCase):
def maybe_do_timeout(self):
# Do the timeout here if we're going to time out.
if self.should_generate_issue():
# We time out this time.
while True:
try:
time.sleep(1)
except:
print("ignoring exception during sleep")
# call parent
super(RerunTimeoutTestCase, self).tearDown()
@decorators.no_debug_info_test
def test_timeout_file_level_timeout_rerun_succeeds(self):
"""Tests that file-level timeout is cleared on rerun."""
# This test just needs to pass. It is the exit hook (outside
# the test method) that will time out.
# Add the exit handler that will time out the first time around.
atexit.register(RerunTimeoutTestCase.maybe_do_timeout, self)

lldb/test/API/issue_verification/TestRerunInline.py.park

  • This file was deleted.
"""Tests that the rerun mechanism respects lldbinline-created tests.
The current implementation of this test is expected to fail both on
the initial run and on the rerun, assuming --rerun-all-issues is provided
to the dotest.py run.
This test could be improved by doing something in the test inferior
C++ program that could look for the "should an issue be raised" marker
file, and then really pass on the rerun.
"""
import lldbsuite.test.lldbinline as lldbinline
lldbinline.MakeInlineTest(__file__, globals())

lldb/test/API/issue_verification/TestRerunTimeout.py.park

  • This file was deleted.
"""Tests that a timeout is detected by the testbot."""
from __future__ import print_function
import time
import lldbsuite.test.decorators as decorators
import rerun_base
class RerunTimeoutTestCase(rerun_base.RerunBaseTestCase):
@decorators.no_debug_info_test
def test_timeout_rerun_succeeds(self):
"""Tests that the timeout logic kicks in and that this timeout is picked up."""
if not self.should_generate_issue():
# We pass this time.
return
# We time out this time.
while True:
# noinspection PyBroadException
try:
time.sleep(1)
except:
print("ignoring exception during sleep")

lldb/test/API/issue_verification/TestSignal.py.park

  • This file was deleted.
"""Tests that an exceptional exit is detected by the testbot."""
import os
import signal
import time
import lldbsuite.test.lldbtest as lldbtest
class ExceptionalExitTestCase(lldbtest.TestBase):
"""Forces exceptional exit."""
mydir = lldbtest.TestBase.compute_mydir(__file__)
@lldbtest.skipIfWindows
def test_buildbot_catches_exceptional_exit(self):
"""Force process to die with exceptional exit."""
# Sleep for a couple seconds
try:
time.sleep(5)
except:
pass
os.kill(os.getpid(), signal.SIGKILL)

lldb/test/API/issue_verification/TestSignalOutsideTestMethod.py.park

  • This file was deleted.
"""Tests that an exceptional exit is detected by the testbot."""
import atexit
import os
import signal
import time
import lldbsuite.test.lldbtest as lldbtest
class ExceptionalExitOutOfTestMethodTestCase(lldbtest.TestBase):
"""Forces exceptional exit."""
mydir = lldbtest.TestBase.compute_mydir(__file__)
@lldbtest.skipIfWindows
def test_buildbot_catches_exceptional_exit(self):
pass
def cleanup():
os.kill(os.getpid(), signal.SIGKILL)
atexit.register(cleanup)

lldb/test/API/issue_verification/TestTimeout.py.park

  • This file was deleted.
"""Tests that a timeout is detected by the testbot."""
from __future__ import print_function
import time
import lldbsuite.test.lldbtest as lldbtest
class TimeoutTestCase(lldbtest.TestBase):
"""Forces test timeout."""
mydir = lldbtest.TestBase.compute_mydir(__file__)
def test_buildbot_catches_timeout(self):
"""Tests that timeout logic kicks in and is picked up."""
while True:
try:
time.sleep(1)
except:
print("ignoring exception during sleep")

lldb/test/API/issue_verification/disable.py

  • This file was deleted.
PropertyOld ValueNew Value
File Mode100755null
#!/usr/bin/env python
"""Renames *.py files to *.py.park."""
import os
import sys
def main():
"""Drives the main script behavior."""
script_dir = os.path.dirname(os.path.realpath(__file__))
for filename in os.listdir(script_dir):
basename, extension = os.path.splitext(filename)
if basename.startswith("Test") and extension == '.py':
source_path = os.path.join(script_dir, filename)
dest_path = source_path + ".park"
sys.stdout.write("renaming {} to {}\n".format(
source_path, dest_path))
os.rename(source_path, dest_path)
if __name__ == "__main__":
main()

lldb/test/API/issue_verification/enable.py

  • This file was deleted.
PropertyOld ValueNew Value
File Mode100755null
#!/usr/bin/env python
"""Renames *.py.park files to *.py."""
import os
import sys
def main():
"""Drives the main script behavior."""
script_dir = os.path.dirname(os.path.realpath(__file__))
for filename in os.listdir(script_dir):
basename, extension = os.path.splitext(filename)
if basename.startswith("Test") and extension == '.park':
source_path = os.path.join(script_dir, filename)
dest_path = os.path.join(script_dir, basename)
sys.stdout.write("renaming {} to {}\n".format(
source_path, dest_path))
os.rename(source_path, dest_path)
if __name__ == "__main__":
main()

lldb/test/API/issue_verification/inline_rerun_inferior.cpp

  • This file was deleted.
typedef int Foo;
int main() {
Foo array[3] = {1,2,3};
return 0; //% self.expect("frame variable array --show-types --", substrs = ['(Foo [3]) wrong_type_here = {','(Foo) [0] = 1','(Foo) [1] = 2','(Foo) [2] = 3'])
}

lldb/test/API/issue_verification/rerun_base.py

  • This file was deleted.
import os
import lldbsuite.test.lldbtest as lldbtest
# pylint: disable=too-few-public-methods
class RerunBaseTestCase(lldbtest.TestBase):
"""Forces test failure."""
mydir = lldbtest.TestBase.compute_mydir(__file__)
def should_generate_issue(self):
"""Returns whether a test issue should be generated.
@returns True on the first and every other call via a given
test method.
"""
should_pass_filename = "{}.{}.succeed-marker".format(
__file__, self.id())
fail = not os.path.exists(should_pass_filename)
if fail:
# Create the marker so that next call to this passes.
open(should_pass_filename, 'w').close()
else:
# Delete the marker so next time we fail.
os.remove(should_pass_filename)
return fail
lldb/test/API/issue_verification/enable.py