2 класс тест величины: Тест. Величины. | Тест по математике (2 класс):

Тест по математике 2 класс тема: Величины УМК «Школа России»

Не пропустите весеннюю распродажу инструментов учителя! Доступ ко всем комплектам со скидкой до 90%

 

СДЕЛАЙТЕ СВОИ УРОКИ ЕЩЁ ЭФФЕКТИВНЕЕ, А ЖИЗНЬ СВОБОДНЕЕ

Благодаря готовым учебным материалам для работы в классе и дистанционно

Выбрать материалы

Скидки до 50 % на комплекты
только до

Готовые ключевые этапы урока всегда будут у вас под рукой

Организационный момент

Проверка знаний

Объяснение материала

Закрепление изученного

Итоги урока

Нахождение величины

Вопрос 1

Периметр квадрата со стороной 3 см равен:

Варианты ответов

• 7 дм
• 12 см
• 30 мм
• 12 м

Вопрос 2

Сколько суток в 2 неделях?

Варианты ответов

• 14
• 24
• 8
• 16

Вопрос 3

длина каждой стороны треугольника равна 2 см. Периметр треугольника равен:

Варианты ответов

• 4 см
• 20 мм
• 6 дм
• 60 мм

Вопрос 4

Алёша младше Маши на 5 лет. Алёше 14 лет. Сколько лет Маше?

Варианты ответов

• 19 лет
• 9 лет

Вопрос 5

Олегу 18 лет. Нина моложе Олега на 3 года.Игорь моложе Нины на 5 лет. Сколько лет Игорю?

Варианты ответов

• 15 лет
• 13 лет
• 10 лет
• 16 лет

Вопрос 6

Сколько часов в трёх сутках?

Варианты ответов

• 72
• 24
• 48
• 36

Вопрос 7

Какой промежуток времени короче: 70 мин или 1 ч?

Варианты ответов

• 70 мин
• 1 ч

Вопрос 8

Часы спешат на 20 мин. Сейчас они показывают 1 ч 30 мин. Сколько времени в действительности?

Варианты ответов

• 1 ч 50 мин
• 1 ч 20 мин
• 1 ч 10 мин
• 1 ч 40 мин

Вопрос 9

Часы показывают 11 часов дня. Они спишат на 3 мин. Какое время в действительности?

Варианты ответов

• 14 ч
• 11 ч 3 мин
• 8 ч
• 10 ч 57 мин

Вопрос 10

Укажи неверную запись.

Варианты ответов

• 5 м = 50 дм
• 1 м > 15 дм
• 4 см
• 20 мм = 2 см

Пройти тест

Сохранить у себя:

© 2021, Бикейкина Наталья Егоровна  305

Тест: Именованные величины — Математика 2 класс

Тест: Именованные величины — Математика 2 класс

Английский язык

Астрономия

Белорусский язык

Биология

География

ИЗО

Информатика

История

Итальянский язык

Краеведение

Литература

Математика

Музыка

Немецкий язык

ОБЖ

Обществознание

Окружающий мир

ОРКСЭ

Русский язык

Технология

Физика

Физкультура

Химия

Черчение

Для учителей

Дошкольникам

VIP — доступ

• Предметы
»
• Математика
»
• 2 класс
»
• Именованные величины

Именованные величины

Сантиметры, дециметры, миллиметры.

Математика 2 класс | Автор: Платонова Елена | ID: 3721 | Дата: 30.1.2015

+12 -8

Помещать страницу в закладки могут только зарегистрированные пользователи
Зарегистрироваться

Вопрос № 1

Сколько см. в 1 дм.?

100
10
1
1000

Вопрос № 2

Сколько мм. в 1 см.?

1000
100
10
1

Вопрос № 3

20 мм, это-

20 см
200 см
2 см
10 см

Вопрос № 4

18 мм, это-

1 см 8 мм
1 дм 8 см
18 см
18дм

Вопрос № 5

2 см 1 мм, это-

21 см
21 мм
21 дм
20 см

Вопрос № 6

3 см, это-

30 дм
30 см
30мм
3 см 3 мм

Вопрос № 7

5 дм — 20 см =

4 дм 80 см
3 дм
30 дм
52 см

Вопрос № 8

6 см — 40 мм =

20 мм
20 дм
2 дм
5 см 60 мм

Вопрос № 9

2 см, это-

200 мм
2 дм
20 мм
22 мм

Вопрос № 10

4 см, это-

40 мм
44 мм
4 дм
400 мм

Вопрос № 11

30 мм, это —

30 см
300 см
3 см
3 дм

Вопрос № 12

10 дм, это-

10 см
10 мм
100 мм
100 см

Вопрос № 13

8 см 5 мм, это —

85 мм
85 см
850 мм
85 дм

Вопрос № 14

3 см 2 мм, это —

32 см
32 дм
32 мм
320 мм

Вопрос № 15

10 мм, это-

1 дм
1 см
10 см
10 дм

Вопрос № 16

10 см, это-

10 мм
100 дм
1 дм
10 дм

Показать ответы

Получение сертификата
о прохождении теста

Доступно только зарегистрированным пользователям

© TestEdu.

ru 2013-2022

E-mail администратора: [email protected]

Тестирование класса эквивалентности в сравнении с тестированием граничного значения

Тестирование класса эквивалентности
Тестирование EC — это когда у вас есть ряд тестовых элементов (например, значений), которые вы хотите протестировать, но из-за затрат (времени/денег) у вас нет время, чтобы проверить их все. Поэтому вы группируете тестовый элемент в класс, где предполагается, что все элементы в каждом классе ведут себя точно так же. Теоретически вам нужно протестировать только один элемент каждого элемента, чтобы убедиться, что система работает.
Пример 1
Дети до 2 лет ездят на автобусе бесплатно. Молодежь платит 10 долларов, взрослые — 15 долларов, а пенсионеры — 5 долларов.
Классы:
Цена:0 -> Возраст:0-1
Цена:10 -> Возраст:2-14
Цена:15 -> Возраст:15-64
Цена:5 -> Возраст:65-бесконечность

Пример 2 (более одного параметра)

Мобильные телефоны K80, J64 и J54 работают на Java 5. K90 и J99 работают на Java 6. Но есть два возможных браузера FireFox и Opera, модели J работают на FF, а модели K на O.
Классы :
Браузер:FF, Java:5 -> Телефоны:J64,J54
Браузер:FF, Java:6 -> Телефоны:J99
Браузер:O, Java:5 -> Телефоны:K80
Браузер:O, Java:6 — > Телефоны: K90

Опасность тестирования класса эквивалентности
Существует опасность использования тестирования EC, которое редко упоминается в книгах по тестированию, но об этом очень важно помнить.
То, что два элемента/значения должны принадлежать одному классу и вести себя одинаково, не означает, что они ДЕЙСТВИТЕЛЬНО ведут себя одинаково.
Это означает, что только потому, что вы тестируете одно значение в классе, ВСЕ значения в классе ведут себя одинаково. Мой реальный пример — мобильные телефоны, у всех которых была определенная платформа Java. Предполагалось, что все они будут работать одинаково, но на самом деле это не так. Таким образом, тестирование только одного значения в классе — это хорошо, но недостаточно.

EC Testing — хороший инструмент, но он не является надежным, и будьте осторожны с ним. Если тестовые примеры дешевы и быстры (например, автоматизация), тестируйте больше или почему бы не протестировать их все!

Тестирование граничных значений
Тестирование BV — это когда вы решаете протестировать значения на границе каждого определенного вами класса. Теория состоит в том, что большинство дефектов находится по краям класса. Пример
Классы:
Цена:0 -> Возраст:0-1 ( Граничные значения 0, 1)
Цена:10 -> Возраст: 2-14 ( Граничные значения 2, 14)
Цена:15 -> Возраст: 15-64 ( Граничные значения 15, 64)
Цена: 5 -> Возраст: 65-бесконечность ( Граничные значения 65)

Критика тестирования граничных значений
1) Я и другие специалисты по тестированию, у которых я проходил курсы, не убеждены, что большинство дефектов скрыто по краям каждого класса. И я никогда не видел исследований, доказывающих, что это так. 2) Тот факт, что вам нужно использовать тестирование BV, доказывает, что тестирование EC ошибочно, поскольку вы тестируете более одного значения каждого класса. 3) Его легко использовать при использовании таких значений, как целые числа. Но что является граничным значением класса моделей телефонов или версий браузеров?

Проверка скрытых граничных значений
Граничные значения класса часто основаны на спецификации того, как должна работать система. Это все хорошо, но большинство систем содержат границы, которые не объясняются ни в одной спецификации, и вам придется искать их самостоятельно. Например. «Сколько символов я могу ввести в тестовое поле, прежде чем система выйдет из строя и сломается». «Насколько большим может стать файл данных, прежде чем он станет настолько медленным для чтения, что станет раздражать».
Реальные примеры
— Вставка миллиона символов в текстовую область в FireFox 3.5 на win 7 приводит к сбою
— ReCaptcha имеет ограничение в 16003 символа, обрабатывает ли ваша система 413, которые она возвращает ей, если кто-то помещает 16004+ символов в поле. Или он ломается?

Резюме
Тестирование EC и BV Testing — отличные инструменты, и вы должны их использовать, но они не идеальны, и не ожидайте, что с их помощью вы обнаружите все дефекты. Используйте свое ноу-хау о системе, свой интеллект и интуицию, чтобы попробовать больше элементов и найти другие причины, по которым она может выйти из строя. И ищите скрытые границы!

Модульный тест Python с базовым и подклассом

спросил 13 лет, 7 месяцев назад

Изменено 12 месяцев назад

Просмотрено 78 тысяч раз

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

 import unittest
класс BaseTest (unittest.TestCase):
    def testCommon(я):
        print 'Вызов BaseTest:testCommon'
        значение = 5
        self. assertEquals (значение, 5)
класс SubTest1 (BaseTest):
    деф testSub1 (я):
        print 'Вызов SubTest1:testSub1'
        суб = 3
        self.assertEquals (sub, 3)
класс SubTest2 (BaseTest):
    деф testSub2 (я):
        print 'Вызов SubTest2:testSub2'
        суб = 4
        self.assertEquals(sub, 4)
если __name__ == '__main__':
    unittest.main()
 

Вывод выше:

 Вызов BaseTest:testCommon
.Вызов BaseTest:testCommon
.Вызов SubTest1:testSub1
.Вызов BaseTest:testCommon
.Вызов SubTest2:testSub2
.
-------------------------------------------------- --------------------
Выполнить 5 тестов за 0,000 с
ХОРОШО
 

Есть ли способ переписать вышесказанное так, чтобы самый первый testCommon не вызывался?

РЕДАКТИРОВАТЬ: Вместо того, чтобы запускать 5 тестов выше, я хочу, чтобы он запускал только 4 теста, 2 из SubTest1 и еще 2 из SubTest2. Похоже, что Python unittest самостоятельно запускает исходный BaseTest, и мне нужен механизм, чтобы этого не произошло.

• Python
• модульное тестирование
• тестирование

2

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

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

 class BaseTestCases:
    класс BaseTest (unittest.TestCase):
        def testCommon(я):
            print('Вызов BaseTest:testCommon')
            значение = 5
            self.assertEqual (значение, 5)
класс SubTest1 (BaseTestCases.BaseTest):
    деф testSub1 (я):
        print('Вызов SubTest1:testSub1')
        суб = 3
        self.assertEqual(sub, 3)
класс SubTest2 (BaseTestCases.BaseTest):
    деф testSub2 (я):
        print('Вызов SubTest2:testSub2')
        суб = 4
        self.assertEqual(sub, 4)
если __name__ == '__main__':
    unittest.main()
 

Вывод:

 Вызов BaseTest:testCommon
.Вызов SubTest1:testSub1
. Вызов BaseTest:testCommon
.Вызов SubTest2:testSub2
.
-------------------------------------------------- --------------------
Провел 4 теста за 0,001 с.
ХОРОШО
 

4

Используйте множественное наследование, чтобы ваш класс с общими тестами сам не наследовал от TestCase.

 импорт юниттест
класс CommonTests (объект):
    def testCommon(я):
        print 'Вызов BaseTest:testCommon'
        значение = 5
        self.assertEquals (значение, 5)
класс SubTest1 (unittest.TestCase, CommonTests):
    деф testSub1 (я):
        print 'Вызов SubTest1:testSub1'
        суб = 3
        self.assertEquals (sub, 3)
класс SubTest2 (unittest.TestCase, CommonTests):
    деф testSub2 (я):
        print 'Вызов SubTest2:testSub2'
        суб = 4
        self.assertEquals(sub, 4)
если __name__ == '__main__':
    unittest.main()
 

8

Вы можете решить эту проблему с помощью одной команды:

 del(BaseTest)
 

Таким образом, код будет выглядеть так:

 import unittest
класс BaseTest (unittest. TestCase):
    def testCommon(я):
        print 'Вызов BaseTest:testCommon'
        значение = 5
        self.assertEquals (значение, 5)
класс SubTest1 (BaseTest):
    деф testSub1 (я):
        print 'Вызов SubTest1:testSub1'
        суб = 3
        self.assertEquals (sub, 3)
класс SubTest2 (BaseTest):
    деф testSub2 (я):
        print 'Вызов SubTest2:testSub2'
        суб = 4
        self.assertEquals(sub, 4)
дел (базовый тест)
если __name__ == '__main__':
    unittest.main()
 

4

Ответ Мэтью Маршалла великолепен, но он требует, чтобы вы наследовали от двух классов в каждом из ваших тестовых случаев, что подвержено ошибкам. Вместо этого я использую это (python>=2.7):

 class BaseTest(unittest.TestCase):
    @классметод
    определение setUpClass (cls):
        если cls — это BaseTest:
            поднять unittest.SkipTest("Пропустить тесты BaseTest, это базовый класс")
        супер(BaseTest, cls).setUpClass()
 

6

Вы можете добавить __test__ = False в класс BaseTest, но если вы добавите его, имейте в виду, что вы должны добавить __test__ = True в производные классы, чтобы иметь возможность запускать тесты.

 импорт юниттест
класс BaseTest (unittest.TestCase):
    __test__ = Ложь
    def testCommon(я):
        print 'Вызов BaseTest:testCommon'
        значение = 5
        self.assertEquals (значение, 5)
класс SubTest1 (BaseTest):
    __test__ = Истина
    деф testSub1 (я):
        print 'Вызов SubTest1:testSub1'
        суб = 3
        self.assertEquals (sub, 3)
класс SubTest2 (BaseTest):
    __test__ = Истина
    деф testSub2 (я):
        print 'Вызов SubTest2:testSub2'
        суб = 4
        self.assertEquals(sub, 4)
если __name__ == '__main__':
    unittest.main()
 

1

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

 импорт юниттест
класс CommonTests (unittest.TestCase):
      def common_assertion(self, foo, bar, baz):
          # любой общий код
          self. assertEqual (foo (bar), baz)
класс BaseTest (CommonTests):
    def testCommon(я):
        print 'Вызов BaseTest:testCommon'
        значение = 5
        self.assertEquals (значение, 5)
класс SubTest1 (общие тесты):
    деф testSub1 (я):
        print 'Вызов SubTest1:testSub1'
        суб = 3
        self.assertEquals (sub, 3)
класс SubTest2 (общие тесты):
    деф testSub2 (я):
        print 'Вызов SubTest2:testSub2'
        суб = 4
        self.assertEquals(sub, 4)
если __name__ == '__main__':
    unittest.main()
 

2

Мне нужно было использовать ответ Мэтью, так как я все еще на 2.5. Но начиная с версии 2.7 вы можете использовать декоратор @unittest.skip() для любых тестовых методов, которые хотите пропустить.

http://docs.python.org/library/unittest.html#skipping-tests-and-expected-failures

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

 def skipBaseTest(obj):
    если тип (объект) — BaseTest:
        return unittest. skip("Тесты BaseTest пропущены")
    возврат лямбда-функции: функция
 

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

По сравнению с методом mixin, ide, такой как PyCharm, не будет жаловаться на отсутствие методов модульного тестирования в базовом классе.

Если базовый класс наследуется от этого класса, ему потребуется переопределить методы setUpClass и tearDownClass .

 класс BaseTest (unittest.TestCase):
    @классметод
    определение setUpClass (cls):
        cls._test_methods = []
        если cls — это BaseTest:
            для имени в каталоге (cls):
                если name.startswith('test') и callable(getattr(cls, name)):
                    cls._test_methods.append((имя, getattr(cls, имя)))
                    setattr(cls, name, lambda self: None)
    @классметод
    def tearDownClass (cls):
        если cls — это BaseTest:
            для имени метод в cls. _test_methods:
                setattr(cls, имя, метод)
            cls._test_methods = []
 

Другой вариант — не выполнять

 unittest.main()
 

Вместо этого вы можете использовать

 suite = unittest.TestLoader().loadTestsFromTestCase(TestClass)
unittest.TextTestRunner(многословие=2).run(набор)
 

Таким образом, вы выполняете тесты только в классе TestClass

1

Я сделал примерно то же, что и @Vladim P. (https://stackoverflow.com/a/25695512/2451329), но немного изменил:

 импорт unittest2
из some_module импортировать func1, func2
определение make_base_class (функция):
    Базовый класс (unittest2.TestCase):
        определение test_common1 (я):
            печать ("в test_common1")
            self.assertTrue (функция ())
        определение test_common2 (я):
            печать ("в test_common1")
            self.assertFalse (функция (42))
    вернуться База
класс A (make_base_class (func1)):
    проходить
класс B (make_base_class (func2)):
    защита test_func2_with_no_arg_return_bar (я):
        self. assertEqual («бар», func2())
 

и поехали.

Начиная с Python 3.2, вы можете добавить функцию test_loader в модуль, чтобы контролировать, какие тесты (если таковые имеются) будут найдены механизмом обнаружения тестов.

Пример: набор = TestSuite () suite.addTests([Подтест1, Подтест2]) возвратный люкс

Должна быть возможность перебрать standard_tests ( TestSuite , содержащий тесты, найденные загрузчиком по умолчанию) и вместо этого скопировать все, кроме Base , в suite , но вложенный характер TestSuite.__iter__ делает это намного сложнее.

Вот решение, которое использует только задокументированные функции модульного тестирования и позволяет избежать статуса «пропустить» в результатах теста:

 class BaseTest(unittest.TestCase):
    def __init__(self, methodName='runTest'):
        если self.__class__ является BaseTest:
            # не запускайте эти тесты в абстрактной базовой реализации
            имя_метода = 'runNoTestsInBaseClass'
        super(). __init__(имя_метода)
    def runNoTestsInBaseClass (я):
        проходить
    def testCommon(я):
        # все остальное как в исходном вопросе
 

Как это работает: согласно документации unittest.TestCase , «Каждый экземпляр TestCase будет запускать один базовый метод: метод с именем methodName». По умолчанию «runTests» запускает все тестовые* методы класса — так обычно работают экземпляры TestCase. Но при работе в самом абстрактном базовом классе вы можете просто переопределить это поведение с помощью метода, который ничего не делает.

Побочным эффектом является увеличение количества тестов на единицу: «тест» runNoTestsInBaseClass считается успешным тестом, когда он выполняется на BaseClass.

(Это также работает в Python 2.7, если вы все еще на нем. Просто измените super() на super(BaseTest, self) .)

Просто переименуйте метод testCommon во что-то другое. Unittest (обычно) пропускает все, в чем нет «теста».

Быстро и просто

 импортировать unittest
  класс BaseTest (unittest. TestCase):
   Метод защитыОбщий(сам):
       print 'Вызов BaseTest:testCommon'
       значение = 5
       self.assertEquals (значение, 5)
  класс SubTest1 (BaseTest):
      деф testSub1 (я):
          print 'Вызов SubTest1:testSub1'
          суб = 3
          self.assertEquals (sub, 3)
  класс SubTest2 (BaseTest):
      деф testSub2 (я):
          print 'Вызов SubTest2:testSub2'
          суб = 4
          self.assertEquals(sub, 4)
  если __name__ == '__main__':
      unittest.main()`
 

1

Итак, это старая тема, но я столкнулся с этой проблемой сегодня и придумал для нее свой собственный хак. Он использует декоратор, который делает значения функций None при доступе через базовый класс. Не нужно беспокоиться о настройке и классе установки, потому что если в базовом классе нет тестов, они не будут выполняться.

 типы импорта
импортировать модульный тест
класс FunctionValueOverride (объект):
    def __init__(self, cls, default, override=None):
        self. cls = клс
        self.default = по умолчанию
        self.override = переопределить
    def __get__(я, объект, класс):
        если класс == self.cls:
            вернуть self.override
        еще:
            если объект:
                возвращаемые типы.MethodType(self.default, obj)
            еще:
                вернуть self.default
Защитное приспособление (cls):
    для t в vars (cls):
        если не вызывается(getattr(cls, t)) или t[:4] != "test":
            продолжать
        setattr(cls, t, FunctionValueOverride(cls, getattr(cls, t)))
    вернуть клс
@фиксация
класс BaseTest (unittest.TestCase):
    def testCommon(я):
        print('Вызов BaseTest:testCommon')
        значение = 5
        self.assertEqual (значение, 5)
класс SubTest1 (BaseTest):
    деф testSub1 (я):
        print('Вызов SubTest1:testSub1')
        суб = 3
        self.assertEqual(sub, 3)
класс SubTest2 (BaseTest):
    деф testSub2 (я):
        print('Вызов SubTest2:testSub2')
        суб = 4
        self.assertEqual(sub, 4)
если __name__ == '__main__':
    unittest. main()
 

Измените имя метода BaseTest на setUp:

 class BaseTest(unittest.TestCase):
    деф setUp(я):
        print 'Вызов BaseTest:testCommon'
        значение = 5
        self.assertEquals (значение, 5)
класс SubTest1 (BaseTest):
    деф testSub1 (я):
        print 'Вызов SubTest1:testSub1'
        суб = 3
        self.assertEquals (sub, 3)
класс SubTest2 (BaseTest):
    деф testSub2 (я):
        print 'Вызов SubTest2:testSub2'
        суб = 4
        self.assertEquals(sub, 4)
 

Вывод:

Выполнить 2 теста за 0,000 с

Calling BaseTest:testCommon Calling
SubTest1:testSub1 Calling
BaseTest:testCommon Calling
SubTest2:testSub2

Из документации:

TestCase.setUp()
Метод, вызываемый для подготовьте испытательное приспособление. Это вызывается непосредственно перед вызовом Метод испытания; любое исключение, вызванное этот метод будет считаться ошибка, а не провал теста.

No related posts.