from selenium import webdriver

driver = webdriver.Chrome()
driver.get("http://www.baidu.com")

driver.set_window_size(800,600)
driver.find_element_by_id("kw").send_keys("selenium")
driver.find_element_by_id("su").click()

# Set the rolling bar of the browser window through JavaScript
js="window.scrollTo(100,450);"
driver.execute_script(js)

from time import sleep
from selenium import webdriver

driver = webdriver.Chrome()
driver.get("http://videojs.com/")

video = driver.find_element_by_id("preview-player_html5_api")

# Return to play file address
url=driver.execute_script("return arguments[0].currentSrc;",video)
print(url)

# Play video
print("start")
driver.execute_script("arguments[0].play()",video)

# Play 15 seconds
sleep(15)

# 1 1 1
print("stop")
driver.execute_script("arguments[0].pause()",video)

driver.quit()

from time import sleep
from selenium import webdriver

driver = webdriver.Chrome()
driver.get("http://www.jq22.com/yanshi4976")
sleep(2)
driver.switch_to.frame("iframe")
driver.find_element_by_id("appDate").click()

# The year, month, and day when positioning to slide
dwwos = driver.find_element_by_class_name("dwwo")
year=dwwos[0]
month=dwwos[1]
day = dwwos[2]

action = webdriver.TouchActions(driver)
action.scroll_from_element(year,0,5).perform()
action.scroll_from_element(month,0,30).perform()
action.scroll_from_element(day,0,30).perform()

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("http://www.baidu.com")

# Intercept the current window, specify the save location of the screenshot picture
driver.save_screenshot("./baidu_img.png")

# Create the Calculator class
import importlib
class Calculator:
    "" "Used to complete the two numbers, subtraction, multiplication, and" "" "
    def __init__(self,a,b):
        self.a = int(a)
        self.b = int(b)

    # 2 2
    def add(self):
        return self.a + self.b

    # subtraction
    def sub(self):
        return self.a - self.b

    # multiplication
    def mul(self):
        return self.a * self.b

    # Except method
    def div(self):
        return self.a / self.b
        
# Test the Calculator class V1 version
from calculator import Calculator
import importlib

def test_add():
    c = Calculator(3,5)
    result = c.add()
    assert result == 8, 'French operation failed'

def test_sub():
    c = Calculator(7,2)
    result = c.sub()
    assert result == 5, 'Decrease operation failed'

def test_mul():
    c = Calculator(3,3)
    result = c.mul()
    assert  result == 10, 'Multipmentual operation failed'

def test_div():
    c = Calculator(6,2)
    result = c.div()
    assert result == 3, 'Failure to except the law'

if __name__ == '__main__':
    test_add()
    test_sub()
    test_mul()
    test_div()

# Test the Calculator class V2 version
import unittest
from calculator import  Calculator

class TestCalculator(unittest.TestCase):
    def test_add(self):
        c = Calculator(3, 5)
        result = c.add()
        self.assertEqual(result,8)


    def test_sub(self):
        c = Calculator(7, 2)
        result = c.sub()
        self.assertEqual(result,5)

    def test_mul(self):
        c = Calculator(3, 3)
        result = c.mul()
        self.assertEqual(result,10)

    def test_div(self):
        c = Calculator(6, 2)
        result = c.div()
        self.assertEqual(result,3)

if __name__ == '__main__':
    unittest.main()
    
# Test the Calculator class V3 version
from calculator import Calculator
import unittest
import importlib

class TestCalculatorV2(unittest.TestCase):
    # 3 3 3 3 3
    def setUp(self):
        print("test start:")

    # Test case post -latter action
    def tearDown(self):
        print("test end")

    def test_add(self):
        c = Calculator(3, 5)
        result = c.add()
        self.assertEqual(result, 8)

    def test_sub(self):
        c = Calculator(7, 2)
        result = c.sub()
        self.assertEqual(result, 5)

    def test_mul(self):
        c = Calculator(3, 3)
        result = c.mul()
        self.assertEqual(result, 10)

    def test_div(self):
        c = Calculator(6, 2)
        result = c.div()
        self.assertEqual(result, 3)

if __name__ == '__main__':
        # Create a test kit
        suit = unittest.TestSuite()
        suit.addTest(TestCalculatorV2("test_add"))
        suit.addTest(TestCalculatorV2("test_sub"))
        suit.addTest(TestCalculatorV2("test_mul"))
        suit.addTest(TestCalculatorV2("test_div"))

        # Create a test operator
        runner = unittest.TextTestRunner()
        runner.run(suit)

import unittest
import importlib

class TestAssert(unittest.TestCase):
    def test_equal(self):
        self.assertEqual(2+2,4)
        self.assertEqual("python","python")
        self.assertNotEqual("hello","python")

    def test_in(self):
        self.assertIn("hello","hello world")
        self.assertNotIn("hi","hello")

    def test_true(self):
        self.assertTrue(True)
        self.assertFalse(False)

if __name__ == '__main__':
    unittest.main()

class LeapYear:
    def __init__(self,year):
        self.year = int(year)

    def answer(self):
        year = self.year
        if year%100==0:
            if year&400==0:
                # The whole hundred years can be removed by 400 is the leap year
                return "{0} is a leap year".format(year)
            else:
                return "{0} Not a leap year".format(year)
        else:
            if year%4==0:
                # 4 4 4 4 4 4 4 4 4 4 4 4 4 4
                return "{0} is a leap year".format(year)
            else:
                return "{0} Not a leap year".format(year)
# Test whether it is a leap year in a certain year
import unittest
import importlib
from leap_year import LeapYear

class TestLeapYear(unittest.TestCase):
    def test_2000(self):
        ly = LeapYear(2000)
        self.assertEqual(ly.answer(),"2000 is a leap year")

    def test_2004(self):
        ly = LeapYear(2004)
        self.assertEqual(ly.answer(),"2004 is a leap year")

    def test_2017(self):
        ly = LeapYear(2017)
        self.assertEqual(ly.answer(),"2017 is not a leap year")

    def test_2100(self):
        ly = LeapYear(2100)
        self.assertEqual(ly.answer(),"2100 is not a leap year")

if __name__=='__main__':
    unittest.main()

#-*-coding: utf-8-*-
#@Time  :2021/12/24 5:26
#@Author: sixiaoyou
#@Email: [email protected]
#@File: TestBdd.py
import unittest
import importlib

class TestBdd(unittest.TestCase):

    def setUp(self):
        print("test TestBdd:")

    def test_ccc(self):
        print("test ccc")

    def test_aaa(self):
        print("test aaa")

class TestAdd(unittest.TestCase):
    def setUp(self):
        print("test TestAdd:")

    def test_bbb(self):
        print("test bbb")

# if __name__ == "__main__":
#     unittest.main()

if __name__=="__main__":
    # Construction test set
    suite = unittest.TestSuite()
    suite.addTest(TestBdd("test_aaa"))
    suite.addTest(TestBdd("test_ccc"))
    suite.addTest(TestAdd("test_bbb"))

    runner = unittest.TextTestRunner()
    runner.run(suite)

import unittest

class MyTest(unittest.TestCase):
    @unittest.skip("Skip test directly")
    def test_skip(self):
        print("test aaa")

    @unittest.skipIf(3>2,"When the condition is the test")
    def test_skip_if(self):
        print("test bbb")

    @unittest.skipUnless(3>2,"Execute test when the condition is true")
    def test_skip_unless(self):
        print('test ccc')

    @unittest.expectedFailure
    def test_expected_failure(self):
        self.assertEqual(2,3)

if __name__=="__main__":
    unittest.main()

import unittest

def setUpModule():
    print("test module start >>>>>>>>>>>>>>>")

def tearDownModule():
    print("test module end >>>>>>>>>>>>>>>>>")

class MyTest(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        print("test class start =============>")

    @classmethod
    def tearDownClass(cls):
        print("test class end ==================>")

    def setUp(self):
        print("test case start -->")

    def tearDown(self):
        print("test case end -->")

    def test_case1(self):
        print("test case1")

    def test_case2(self):
        print("test case2")

if __name__ == "__main__":
    unittest.main()

import unittest

# The directory of the test case is the test_case/directory in the current directory
test_dir ='../20211220'
suits=unittest.defaultTestLoader.discover(test_dir,pattern='test*.py')

if __name__=="__main__":
    runner = unittest.TextTestRunner()
    runner.run(suits)

# Test Baidu V1
import unittest
from time import sleep
from selenium import webdriver

class TestBaidu(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.base_url = "https://www.baidu.com"

    def test_search_key_selenium(self):
        self.driver.get(self.base_url)
        self.driver.find_element_by_id("kw").send_keys("selenium")
        self.driver.find_element_by_id("su").click()
        sleep(2)
        title = self.driver.title
        self.assertEqual(title,"Selenium_ 百度 5")

    def test_search_key_unittest(self):
        self.driver.get(self.base_url)
        self.driver.find_element_by_id("kw").send_keys(("unittest"))
        self.driver.find_element_by_id("su").click()
        sleep(2)
        title=self.driver.title
        self.assertEqual(title,"Unittest_ 百度 搜")

    def tearDown(self):
        self.driver.quit()

if __name__=="__main__":
    unittest.main()

# Test Baidu V2
import unittest
from time import sleep
from selenium import webdriver

class TestBaiduV2(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.base_url = "http://www.baidu.com"

    def baidu_search(self,search_key):
        self.driver.get(self.base_url)
        self.driver.find_element_by_id("kw").send_keys(search_key)
        self.driver.find_element_by_id("su").click()
        sleep(2)

    def test_search_key_selenium(self):
        search_key = "selenium"
        self.baidu_search(search_key)
        self.assertEqual(self.driver.title,search_key+"_ 百度 5")

    def test_search_key_unittest(self):
        search_key = "unittest"
        self.baidu_search(search_key)
        self.assertEqual(self.driver.title,search_key + "_ 百度 5")

    def tearDown(self):
        self.driver.quit()

if __name__=="__main__":
    unittest.main()

# Test Baidu V3
from time import sleep
from selenium import webdriver

class TestBaiduV3(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.driver = webdriver.Chrome()
        cls.base_url = "http://www.baidu.com"

    def baidu_search(self,search_key):
        self.driver.get(self.base_url)
        self.driver.find_element_by_id("kw").send_keys(search_key)
        self.driver.find_element_by_id("su").click()
        sleep(2)

    def test_search_key_selenium(self):
        search_key = "selenium"
        self.baidu_search(search_key)
        self.assertEqual(self.driver.title,search_key+"_ 百度 6")

    def test_search_key_unittest(self):
        search_key = "unittest"
        self.baidu_search(search_key)
        self.assertEqual(self.driver.title,search_key + "_ 百度 6")

    @classmethod
    def tearDownClass(cls):
        cls.driver.quit()

if __name__=="__main__":
    unittest.main()