一款简单易用的.Net 断言测试框架： Shouldly

GitHub地址：https://github.com/shouldly/shouldly

Shouldly的官方文档：http://docs.shouldly-lib.net/

Nuget安装：

在测试类中引用：

using Shouldly;

用法：

//验证

            UsingDbContext(context =>

            {

                var bill = context.Bills.FirstOrDefault();

                bill.ShouldNotBeNull();

            });

我们看一下，ShouldNotBeNull是如何定义的，其实就是在在原类型的基础上加的扩展方法。

namespace Shouldly

{

    [DebuggerStepThrough]

    [ShouldlyMethods]

    public static class ShouldBeNullExtensions

    {

        public static void ShouldBeNull<T>(this T actual);

        public static void ShouldBeNull<T>(this T actual, string customMessage);

        public static void ShouldBeNull<T>(this T actual, [InstantHandle] Func<string> customMessage);

        [ContractAnnotation("actual:null => halt")]

        public static void ShouldNotBeNull<T>(this T actual);

        [ContractAnnotation("actual:null => halt")]

        public static void ShouldNotBeNull<T>(this T actual, string customMessage);

        [ContractAnnotation("actual:null => halt")]

        public static void ShouldNotBeNull<T>(this T actual, [InstantHandle] Func<string> customMessage);

    }

}

[DebuggerStepThrough]

    [ShouldlyMethods]

    public static class ShouldBeTestExtensions

    {

        public static void ShouldBe(this decimal actual, decimal expected, decimal tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldBe(this DateTime actual, DateTime expected, TimeSpan tolerance);

        public static void ShouldBe(this DateTime actual, DateTime expected, TimeSpan tolerance, string customMessage);

        public static void ShouldBe(this DateTime actual, DateTime expected, TimeSpan tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldBe(this DateTimeOffset actual, DateTimeOffset expected, TimeSpan tolerance);

        public static void ShouldBe(this DateTimeOffset actual, DateTimeOffset expected, TimeSpan tolerance, string customMessage);

        public static void ShouldBe(this DateTimeOffset actual, DateTimeOffset expected, TimeSpan tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldBe(this TimeSpan actual, TimeSpan expected, TimeSpan tolerance);

        public static void ShouldBe(this TimeSpan actual, TimeSpan expected, TimeSpan tolerance, string customMessage);

        public static void ShouldBe(this TimeSpan actual, TimeSpan expected, TimeSpan tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldBe<T>(this T actual, T expected);

        public static void ShouldBe<T>(this T actual, T expected, string customMessage);

        public static void ShouldBe<T>(this T actual, T expected, [InstantHandle] Func<string> customMessage);

        public static void ShouldBe<T>(this IEnumerable<T> actual, IEnumerable<T> expected, bool ignoreOrder = false);

        public static void ShouldBe(this decimal actual, decimal expected, decimal tolerance, string customMessage);

        public static void ShouldBe<T>(this IEnumerable<T> actual, IEnumerable<T> expected, bool ignoreOrder, [InstantHandle] Func<string> customMessage);

        public static void ShouldBe<T>(this IEnumerable<T> actual, IEnumerable<T> expected, bool ignoreOrder, string customMessage);

        public static void ShouldBe(this IEnumerable<decimal> actual, IEnumerable<decimal> expected, decimal tolerance, string customMessage);

        public static void ShouldBe(this decimal actual, decimal expected, decimal tolerance);

        public static void ShouldBe(this double actual, double expected, double tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldBe(this double actual, double expected, double tolerance, string customMessage);

        public static void ShouldBe(this double actual, double expected, double tolerance);

        public static void ShouldBe(this IEnumerable<decimal> actual, IEnumerable<decimal> expected, decimal tolerance);

        public static void ShouldBe(this IEnumerable<float> actual, IEnumerable<float> expected, double tolerance, string customMessage);

        public static void ShouldBe(this IEnumerable<float> actual, IEnumerable<float> expected, double tolerance);

        public static void ShouldBe(this IEnumerable<float> actual, IEnumerable<float> expected, double tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldBe(this IEnumerable<double> actual, IEnumerable<double> expected, double tolerance, string customMessage);

        public static void ShouldBe(this IEnumerable<double> actual, IEnumerable<double> expected, double tolerance);

        public static void ShouldBe(this float actual, float expected, double tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldBe(this float actual, float expected, double tolerance, string customMessage);

        public static void ShouldBe(this float actual, float expected, double tolerance);

        public static void ShouldBe(this IEnumerable<decimal> actual, IEnumerable<decimal> expected, decimal tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldBe(this IEnumerable<double> actual, IEnumerable<double> expected, double tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldBeAssignableTo(this object actual, Type expected, [InstantHandle] Func<string> customMessage);

        public static void ShouldBeAssignableTo(this object actual, Type expected, string customMessage);

        public static void ShouldBeAssignableTo(this object actual, Type expected);

        public static T ShouldBeAssignableTo<T>(this object actual, [InstantHandle] Func<string> customMessage);

        public static T ShouldBeAssignableTo<T>(this object actual);

        public static T ShouldBeAssignableTo<T>(this object actual, string customMessage);

        public static void ShouldBeGreaterThan<T>(this T actual, T expected) where T : IComparable<T>;

        public static void ShouldBeGreaterThan<T>(this T actual, T expected, IComparer<T> comparer);

        public static void ShouldBeGreaterThan<T>(this T actual, T expected, IComparer<T> comparer, string customMessage);

        public static void ShouldBeGreaterThan<T>(this T actual, T expected, IComparer<T> comparer, Func<string> customMessage);

        public static void ShouldBeGreaterThan<T>(this T actual, T expected, string customMessage) where T : IComparable<T>;

        public static void ShouldBeGreaterThan<T>(this T actual, T expected, [InstantHandle] Func<string> customMessage) where T : IComparable<T>;

        public static void ShouldBeGreaterThanOrEqualTo<T>(this T actual, T expected, [InstantHandle] Func<string> customMessage) where T : IComparable<T>;

        public static void ShouldBeGreaterThanOrEqualTo<T>(this T actual, T expected, IComparer<T> comparer, string customMessage);

        public static void ShouldBeGreaterThanOrEqualTo<T>(this T actual, T expected, IComparer<T> comparer);

        public static void ShouldBeGreaterThanOrEqualTo<T>(this T actual, T expected, string customMessage) where T : IComparable<T>;

        public static void ShouldBeGreaterThanOrEqualTo<T>(this T actual, T expected) where T : IComparable<T>;

        public static void ShouldBeGreaterThanOrEqualTo<T>(this T actual, T expected, IComparer<T> comparer, Func<string> customMessage);

        public static void ShouldBeInRange<T>(this T actual, T from, T to, [InstantHandle] Func<string> customMessage) where T : IComparable<T>;

        public static void ShouldBeInRange<T>(this T actual, T from, T to, string customMessage) where T : IComparable<T>;

        public static void ShouldBeInRange<T>(this T actual, T from, T to) where T : IComparable<T>;

        public static void ShouldBeLessThan<T>(this T actual, T expected, IComparer<T> comparer, Func<string> customMessage);

        public static void ShouldBeLessThan<T>(this T actual, T expected, IComparer<T> comparer, string customMessage);

        public static void ShouldBeLessThan<T>(this T actual, T expected, IComparer<T> comparer);

        public static void ShouldBeLessThan<T>(this T actual, T expected, string customMessage) where T : IComparable<T>;

        public static void ShouldBeLessThan<T>(this T actual, T expected) where T : IComparable<T>;

        public static void ShouldBeLessThan<T>(this T actual, T expected, [InstantHandle] Func<string> customMessage) where T : IComparable<T>;

        public static void ShouldBeLessThanOrEqualTo<T>(this T actual, T expected, [InstantHandle] Func<string> customMessage) where T : IComparable<T>;

        public static void ShouldBeLessThanOrEqualTo<T>(this T actual, T expected, IComparer<T> comparer, Func<string> customMessage);

        public static void ShouldBeLessThanOrEqualTo<T>(this T actual, T expected, IComparer<T> comparer);

        public static void ShouldBeLessThanOrEqualTo<T>(this T actual, T expected, string customMessage) where T : IComparable<T>;

        public static void ShouldBeLessThanOrEqualTo<T>(this T actual, T expected) where T : IComparable<T>;

        public static void ShouldBeLessThanOrEqualTo<T>(this T actual, T expected, IComparer<T> comparer, string customMessage);

        public static void ShouldBeNegative(this decimal actual);

        public static void ShouldBeNegative(this decimal actual, string customMessage);

        public static void ShouldBeNegative(this decimal actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBeNegative(this double actual, string customMessage);

        public static void ShouldBeNegative(this double actual);

        public static void ShouldBeNegative(this double actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBeNegative(this float actual);

        public static void ShouldBeNegative(this long actual, string customMessage);

        public static void ShouldBeNegative(this short actual, string customMessage);

        public static void ShouldBeNegative(this short actual);

        public static void ShouldBeNegative(this long actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBeNegative(this long actual);

        public static void ShouldBeNegative(this int actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBeNegative(this int actual, string customMessage);

        public static void ShouldBeNegative(this int actual);

        public static void ShouldBeNegative(this short actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBeNegative(this float actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBeNegative(this float actual, string customMessage);

        public static T ShouldBeOfType<T>(this object actual);

        public static T ShouldBeOfType<T>(this object actual, string customMessage);

        public static void ShouldBeOfType(this object actual, Type expected, string customMessage);

        public static void ShouldBeOfType(this object actual, Type expected, [InstantHandle] Func<string> customMessage);

        public static T ShouldBeOfType<T>(this object actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBeOfType(this object actual, Type expected);

        public static void ShouldBeOneOf<T>(this T actual, T[] expected, string customMessage);

        public static void ShouldBeOneOf<T>(this T actual, params T[] expected);

        public static void ShouldBeOneOf<T>(this T actual, T[] expected, [InstantHandle] Func<string> customMessage);

        public static void ShouldBePositive(this float actual, string customMessage);

        public static void ShouldBePositive(this decimal actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBePositive(this short actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBePositive(this short actual, string customMessage);

        public static void ShouldBePositive(this short actual);

        public static void ShouldBePositive(this decimal actual);

        public static void ShouldBePositive(this decimal actual, string customMessage);

        public static void ShouldBePositive(this float actual);

        public static void ShouldBePositive(this double actual);

        public static void ShouldBePositive(this double actual, string customMessage);

        public static void ShouldBePositive(this double actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBePositive(this float actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBePositive(this long actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBePositive(this long actual, string customMessage);

        public static void ShouldBePositive(this long actual);

        public static void ShouldBePositive(this int actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldBePositive(this int actual, string customMessage);

        public static void ShouldBePositive(this int actual);

        public static void ShouldBeSameAs(this object actual, object expected, string customMessage);

        public static void ShouldBeSameAs(this object actual, object expected, [InstantHandle] Func<string> customMessage);

        public static void ShouldBeSameAs(this object actual, object expected);

        [ContractAnnotation("actual:null,expected:null => halt")]

        public static void ShouldNotBe<T>(this T actual, T expected, [InstantHandle] Func<string> customMessage);

        [ContractAnnotation("actual:null,expected:null => halt")]

        public static void ShouldNotBe<T>(this T actual, T expected, string customMessage);

        [ContractAnnotation("actual:null,expected:null => halt")]

        public static void ShouldNotBe<T>(this T actual, T expected);

        public static void ShouldNotBe(this DateTimeOffset actual, DateTimeOffset expected, TimeSpan tolerance, string customMessage);

        public static void ShouldNotBe(this TimeSpan actual, TimeSpan expected, TimeSpan tolerance, string customMessage);

        public static void ShouldNotBe(this TimeSpan actual, TimeSpan expected, TimeSpan tolerance);

        public static void ShouldNotBe(this DateTimeOffset actual, DateTimeOffset expected, TimeSpan tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldNotBe(this DateTimeOffset actual, DateTimeOffset expected, TimeSpan tolerance);

        public static void ShouldNotBe(this DateTime actual, DateTime expected, TimeSpan tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldNotBe(this DateTime actual, DateTime expected, TimeSpan tolerance, string customMessage);

        public static void ShouldNotBe(this DateTime actual, DateTime expected, TimeSpan tolerance);

        public static void ShouldNotBe(this TimeSpan actual, TimeSpan expected, TimeSpan tolerance, [InstantHandle] Func<string> customMessage);

        public static void ShouldNotBeAssignableTo(this object actual, Type expected);

        public static void ShouldNotBeAssignableTo<T>(this object actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldNotBeAssignableTo<T>(this object actual, string customMessage);

        public static void ShouldNotBeAssignableTo(this object actual, Type expected, [InstantHandle] Func<string> customMessage);

        public static void ShouldNotBeAssignableTo(this object actual, Type expected, string customMessage);

        public static void ShouldNotBeAssignableTo<T>(this object actual);

        public static void ShouldNotBeInRange<T>(this T actual, T from, T to) where T : IComparable<T>;

        public static void ShouldNotBeInRange<T>(this T actual, T from, T to, [InstantHandle] Func<string> customMessage) where T : IComparable<T>;

        public static void ShouldNotBeInRange<T>(this T actual, T from, T to, string customMessage) where T : IComparable<T>;

        public static void ShouldNotBeOfType(this object actual, Type expected, string customMessage);

        public static void ShouldNotBeOfType<T>(this object actual, string customMessage);

        public static void ShouldNotBeOfType(this object actual, Type expected);

        public static void ShouldNotBeOfType(this object actual, Type expected, [InstantHandle] Func<string> customMessage);

        public static void ShouldNotBeOfType<T>(this object actual);

        public static void ShouldNotBeOfType<T>(this object actual, [InstantHandle] Func<string> customMessage);

        public static void ShouldNotBeOneOf<T>(this T actual, T[] expected, [InstantHandle] Func<string> customMessage);

        public static void ShouldNotBeOneOf<T>(this T actual, T[] expected, string customMessage);

        public static void ShouldNotBeOneOf<T>(this T actual, params T[] expected);

        public static void ShouldNotBeSameAs(this object actual, object expected, [InstantHandle] Func<string> customMessage);

        public static void ShouldNotBeSameAs(this object actual, object expected, string customMessage);

        public static void ShouldNotBeSameAs(this object actual, object expected);

    }

当测试失败时，

异常测试：

                var bill = context.Bills.FirstOrDefault();

                Should.Throw<DivideByZeroException>(() =>

                {

                    bill.SetBmiNoPay();

                });

测试结果：

一款简单易用的.Net 断言测试框架： Shouldly的更多相关文章

推荐一款简单易用线上引流测试工具：GoReplay
一. 引流测试产生背景日常大部分的测试工作都是在测试环境下,通过模拟用户的行为来对系统进行验证,包括功能以及性能.在这个过程中,你可能会遇到以下问题: 用户访问行为比较复杂,模拟很难和用户行为一致, ...
简单易用的leetcode开发测试工具（npm）
描述最近在用es6解leetcode,当问题比较复杂时,有可能修正了新的错误,却影响了前面的流程.要用通用的测试工具,却又有杀鸡用牛刀的感觉,所以就写了个简单易用的leetcode开发测试工具,分享 ...
设计与开发一款简单易用的Web报表工具（支持常用关系数据及hadoop、hbase等)
EasyReport是一个简单易用的Web报表工具(支持Hadoop,HBase及各种关系型数据库),它的主要功能是把SQL语句查询出的行列结构转换成HTML表格(Table),并支持表格的跨行(Ro ...
Criterion - 一个简单可扩展的 C 语言测试框架
A dead-simple, yet extensible, C test framework. Philosophy Most test frameworks for C require a lot ...
如何以最简单的方式安装 KALI 渗透测试框架系统
0x01 第一步下载 KALI 百度搜索 KALI 官网,找到下载区,我选的是 64 位标准版,但是推荐下载 32 位(功能貌似更全) 这个为下载后的 iso 镜像文件 0x02 第二步打开虚拟机,配 ...
简单易用的堡垒机系统—Teleport
简单易用的堡垒机系统-Teleport 官方文档:http://teleport.eomsoft.net/doc#!1 一.Teleport介绍 Teleport是触维软件推出的一款简单易用的堡垒机 ...
消灭Bug！十款免费移动应用测试框架推荐
对于移动应用开发者而言,Bug往往是最让人头疼的一大问题.不同于时时刻刻可以修补的Web App,移动App中的Bug往往隐藏得很深,甚至有时候等到用户使用才显现出来,这么一来开发者搞不好就会赔了 ...
hapi lab测试框架简单使用
1. 依赖安装 yarn init yarn add lab code 2. 基本模式 const Lab = require('lab'); const Code = require('code') ...
[.net 面向对象程序设计进阶] (22) 团队开发利器（一）简单易用的代码管理工具VSS
[.net 面向对象程序设计进阶] (22) 团队开发利器(一)简单易用的代码管理工具VSS 本篇要点:在进阶篇快要结束的时候说说源代码管理器,我们的开发,不是一个人可以完成的事,团队协作很重要,而且 ...

随机推荐

Azkaban简介及使用
一.Azkaban概述 Azkaban是一个分布式工作流管理器,在LinkedIn上实现,以解决Hadoop作业依赖性问题. 我们有需要按顺序运行的工作,从ETL工作到数据分析产品. 特点: 1)给用 ...
Pycharm建立web2py项目并简单连接MySQL数据库
引言 web2py是一种免费的,开源的web开发框架,用于敏捷地开发安全的,数据库驱动的web应用:web2p采用Python语言编写,并且可以使用Python编程.web2py是一个完整的堆栈框架, ...
图文讲解zabbix安装全过程（5）
在了解<zabbix硬件.软件需求>之后,在你心里应该有备选的机器.今天开始安装zabbix.zabbix需要LNMP或者LAMP环境.环境的搭建不在本章范围内. LNMP环境配置Linu ...
CanvasRenderingContext2D.lineDashOffset
https://developer.mozilla.org/zh-CN/docs/Web/API/CanvasRenderingContext2D/lineDashOffset CanvasRende ...
机器学习算法（优化）之一：梯度下降算法、随机梯度下降（应用于线性回归、Logistic回归等等）
本文介绍了机器学习中基本的优化算法—梯度下降算法和随机梯度下降算法,以及实际应用到线性回归.Logistic回归.矩阵分解推荐算法等ML中. 梯度下降算法基本公式常见的符号说明和损失函数 X :所有 ...
js如何打印对象
js调试中经常会碰到输出的内容是对象而无法打印的时候,光靠alert只能打印出object标示,却不能打印出来里面的内容,甚是不方便,于是各方面整理总结了如下一个函数,能够将数组或者对象这类的结果一一 ...
mysql数据库从删库到跑路之mysql基础
一数据库是什么之前所学,数据要永久保存,比如用户注册的用户信息,都是保存于文件中,而文件只能存在于某一台机器上. 如果我们不考虑从文件中读取数据的效率问题,并且假设我们的程序所有的组件都运行在一台 ...
SQL Server 使用 Pivot 和 UnPivot 实现行列转换
对于行列转换的数据,通常也就是在做报表的时候用的比较多,之前也零零散散的看了一些,今天就来总结一下. 先创建一个用于演示的临时表: create table #temp ( 年份 ) null, 月份 ...
tensorboard实现训练的可视化
tensorboard是tensorflow自带的可视化工具输入命令可以启动tensorboard服务. tensorboard --logdir=your log dir 通过浏览器localho ...
redis数据持久化内存不足
原因:写数据到redis里面写不进去,查看redis日志显示: Can't save in background: fork: Cannot allocate memory 在小内存的进程上做一个fo ...

一款简单易用的.Net 断言测试框架 ： Shouldly

一款简单易用的.Net 断言测试框架 ： Shouldly的更多相关文章

随机推荐

热门专题

一款简单易用的.Net 断言测试框架： Shouldly

一款简单易用的.Net 断言测试框架： Shouldly的更多相关文章