All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.scalatest.matchers.dsl.ResultOfContainWord.scala Maven / Gradle / Ivy

The newest version!
/*
 * Copyright 2001-2013 Artima, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.scalatest.matchers.dsl

import scala.collection.GenTraversable
import org.scalatest.enablers.Containing
import org.scalatest.enablers.Aggregating
import org.scalatest.enablers.Sequencing
import org.scalatest.enablers.KeyMapping
import org.scalatest.enablers.ValueMapping
import org.scalatest.FailureMessages
import org.scalatest.UnquotedString
import org.scalatest.exceptions.NotAllowedException
import org.scalatest.Assertion
import org.scalatest.matchers.MatchersHelper.indicateSuccess
import org.scalatest.matchers.MatchersHelper.indicateFailure
import org.scalactic._

/**
 * This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
 * the matchers DSL.
 *
 * @author Bill Venners
 */
class ResultOfContainWord[L](left: L, shouldBeTrue: Boolean, prettifier: Prettifier, pos: source.Position) {

  /**
   * This method enables the following syntax: 
   *
   * 
   * xs should contain oneOf (1, 2)
   *                   ^
   * 
**/ infix def oneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit containing: Containing[L]): Assertion = { val right = firstEle :: secondEle :: remainingEles.toList if (right.distinct.size != right.size) throw new NotAllowedException(FailureMessages.oneOfDuplicate, pos) if (containing.containsOneOf(left, right) != shouldBeTrue) indicateFailure( if (shouldBeTrue) FailureMessages.didNotContainOneOfElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.containedOneOfElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), None, pos ) else indicateSuccess( shouldBeTrue, FailureMessages.containedOneOfElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), FailureMessages.didNotContainOneOfElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) ) } /** * This method enables the following syntax: * *
   * xs should contain oneElementOf List(1, 2)
   *                   ^
   * 
**/ infix def oneElementOf(elements: GenTraversable[Any])(implicit containing: Containing[L]): Assertion = { val right = elements.toList if (containing.containsOneOf(left, right.distinct) != shouldBeTrue) indicateFailure(if (shouldBeTrue) FailureMessages.didNotContainOneElementOf(prettifier, left, right) else FailureMessages.containedOneElementOf(prettifier, left, right), None, pos) else indicateSuccess(shouldBeTrue, FailureMessages.containedOneElementOf(prettifier, left, right), FailureMessages.didNotContainOneElementOf(prettifier, left, right)) } /** * This method enables the following syntax: * *
   * xs should contain atLeastOneOf (1, 2)
   *                   ^
   * 
**/ infix def atLeastOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit aggregating: Aggregating[L]): Assertion = { val right = firstEle :: secondEle :: remainingEles.toList if (right.distinct.size != right.size) throw new NotAllowedException(FailureMessages.atLeastOneOfDuplicate, pos) if (aggregating.containsAtLeastOneOf(left, right) != shouldBeTrue) indicateFailure( if (shouldBeTrue) FailureMessages.didNotContainAtLeastOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.containedAtLeastOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), None, pos ) else indicateSuccess( shouldBeTrue, FailureMessages.containedAtLeastOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), FailureMessages.didNotContainAtLeastOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) ) } /** * This method enables the following syntax: * *
   * xs should contain atLeastOneElementOf List(1, 2)
   *                   ^
   * 
**/ infix def atLeastOneElementOf(elements: GenTraversable[Any])(implicit aggregating: Aggregating[L]): Assertion = { val right = elements.toList if (aggregating.containsAtLeastOneOf(left, right.distinct) != shouldBeTrue) indicateFailure(if (shouldBeTrue) FailureMessages.didNotContainAtLeastOneElementOf(prettifier, left, right) else FailureMessages.containedAtLeastOneElementOf(prettifier, left, right), None, pos) else indicateSuccess(shouldBeTrue, FailureMessages.containedAtLeastOneElementOf(prettifier, left, right), FailureMessages.didNotContainAtLeastOneElementOf(prettifier, left, right)) } /** * This method enables the following syntax: * *
   * xs should contain noneOf (1, 2)
   *                   ^
   * 
**/ infix def noneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit containing: Containing[L]): Assertion = { val right = firstEle :: secondEle :: remainingEles.toList if (right.distinct.size != right.size) throw new NotAllowedException(FailureMessages.noneOfDuplicate, pos) if (containing.containsNoneOf(left, right) != shouldBeTrue) indicateFailure( if (shouldBeTrue) FailureMessages.containedAtLeastOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.didNotContainAtLeastOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), None, pos ) else indicateSuccess( shouldBeTrue, FailureMessages.didNotContainAtLeastOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), FailureMessages.containedAtLeastOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) ) } /** * This method enables the following syntax: * *
   * xs should contain noElementsOf List(1, 2)
   *                   ^
   * 
**/ infix def noElementsOf(elements: GenTraversable[Any])(implicit containing: Containing[L]): Assertion = { val right = elements.toList if (containing.containsNoneOf(left, right.distinct) != shouldBeTrue) indicateFailure(if (shouldBeTrue) FailureMessages.containedAtLeastOneElementOf(prettifier, left, right) else FailureMessages.didNotContainAtLeastOneElementOf(prettifier, left, right), None, pos) else indicateSuccess(shouldBeTrue, FailureMessages.didNotContainAtLeastOneElementOf(prettifier, left, right), FailureMessages.containedAtLeastOneElementOf(prettifier, left, right)) } /** * This method enables the following syntax: * *
   * xs should contain theSameElementsAs (List(1, 2))
   *                   ^
   * 
**/ infix def theSameElementsAs(right: GenTraversable[_])(implicit aggregating: Aggregating[L]): Assertion = { if (aggregating.containsTheSameElementsAs(left, right) != shouldBeTrue) indicateFailure(if (shouldBeTrue) FailureMessages.didNotContainSameElements(prettifier, left, right) else FailureMessages.containedSameElements(prettifier, left, right), None, pos) else indicateSuccess(shouldBeTrue, FailureMessages.containedSameElements(prettifier, left, right), FailureMessages.didNotContainSameElements(prettifier, left, right)) } /** * This method enables the following syntax: * *
   * xs should contain theSameElementsInOrderAs (List(1, 2))
   *                   ^
   * 
**/ infix def theSameElementsInOrderAs(right: GenTraversable[_])(implicit sequencing: Sequencing[L]): Assertion = { if (sequencing.containsTheSameElementsInOrderAs(left, right) != shouldBeTrue) indicateFailure(if (shouldBeTrue) FailureMessages.didNotContainSameElementsInOrder(prettifier, left, right) else FailureMessages.containedSameElementsInOrder(prettifier, left, right), None, pos) else indicateSuccess(shouldBeTrue, FailureMessages.containedSameElementsInOrder(prettifier, left, right), FailureMessages.didNotContainSameElementsInOrder(prettifier, left, right)) } /** * This method enables the following syntax: * *
   * xs should contain only (1, 2)
   *                   ^
   * 
**/ infix def only(right: Any*)(implicit aggregating: Aggregating[L]): Assertion = { if (right.isEmpty) throw new NotAllowedException(FailureMessages.onlyEmpty, pos) if (right.distinct.size != right.size) throw new NotAllowedException(FailureMessages.onlyDuplicate, pos) val withFriendlyReminder = right.size == 1 && (right(0).isInstanceOf[scala.collection.GenTraversable[_]] || right(0).isInstanceOf[Every[_]]) if (aggregating.containsOnly(left, right) != shouldBeTrue) { indicateFailure( if (shouldBeTrue) if (withFriendlyReminder) FailureMessages.didNotContainOnlyElementsWithFriendlyReminder(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.didNotContainOnlyElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else if (withFriendlyReminder) FailureMessages.containedOnlyElementsWithFriendlyReminder(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.containedOnlyElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), None, pos ) } else indicateSuccess( if (shouldBeTrue) if (withFriendlyReminder) FailureMessages.containedOnlyElementsWithFriendlyReminder(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.containedOnlyElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else if (withFriendlyReminder) FailureMessages.didNotContainOnlyElementsWithFriendlyReminder(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.didNotContainOnlyElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) ) } /** * This method enables the following syntax: * *
   * xs should contain inOrderOnly (1, 2)
   *                   ^
   * 
**/ infix def inOrderOnly(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit sequencing: Sequencing[L]): Assertion = { val right = firstEle :: secondEle :: remainingEles.toList if (right.distinct.size != right.size) throw new NotAllowedException(FailureMessages.inOrderOnlyDuplicate, pos) if (sequencing.containsInOrderOnly(left, right) != shouldBeTrue) indicateFailure( if (shouldBeTrue) FailureMessages.didNotContainInOrderOnlyElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.containedInOrderOnlyElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), None, pos ) else indicateSuccess( shouldBeTrue, FailureMessages.containedInOrderOnlyElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), FailureMessages.didNotContainInOrderOnlyElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) ) } /** * This method enables the following syntax: * *
   * xs should contain allOf (1, 2)
   *                   ^
   * 
**/ infix def allOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit aggregating: Aggregating[L]): Assertion = { val right = firstEle :: secondEle :: remainingEles.toList if (right.distinct.size != right.size) throw new NotAllowedException(FailureMessages.allOfDuplicate, pos) if (aggregating.containsAllOf(left, right) != shouldBeTrue) indicateFailure( if (shouldBeTrue) FailureMessages.didNotContainAllOfElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.containedAllOfElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), None, pos ) else indicateSuccess( shouldBeTrue, FailureMessages.didNotContainAllOfElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), FailureMessages.containedAllOfElements(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) ) } /** * This method enables the following syntax: * *
   * xs should contain allElementsOf (1, 2)
   *                   ^
   * 
**/ infix def allElementsOf[R](elements: GenTraversable[R])(implicit aggregating: Aggregating[L]): Assertion = { val right = elements.toList if (aggregating.containsAllOf(left, right.distinct) != shouldBeTrue) indicateFailure(if (shouldBeTrue) FailureMessages.didNotContainAllElementsOf(prettifier, left, right) else FailureMessages.containedAllElementsOf(prettifier, left, right), None, pos) else indicateSuccess(shouldBeTrue, FailureMessages.containedAllElementsOf(prettifier, left, right), FailureMessages.didNotContainAllElementsOf(prettifier, left, right)) } /** * This method enables the following syntax: * *
   * xs should contain inOrder (1, 2)
   *                   ^
   * 
**/ infix def inOrder(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit sequencing: Sequencing[L]): Assertion = { val right = firstEle :: secondEle :: remainingEles.toList if (right.distinct.size != right.size) throw new NotAllowedException(FailureMessages.inOrderDuplicate, pos) if (sequencing.containsInOrder(left, right) != shouldBeTrue) indicateFailure( if (shouldBeTrue) FailureMessages.didNotContainAllOfElementsInOrder(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.containedAllOfElementsInOrder(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), None, pos ) else indicateSuccess( shouldBeTrue, FailureMessages.containedAllOfElementsInOrder(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), FailureMessages.didNotContainAllOfElementsInOrder(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) ) } /** * This method enables the following syntax: * *
   * xs should contain inOrderElementsOf List(1, 2)
   *                   ^
   * 
**/ infix def inOrderElementsOf[R](elements: GenTraversable[R])(implicit sequencing: Sequencing[L]): Assertion = { val right = elements.toList if (sequencing.containsInOrder(left, right.distinct) != shouldBeTrue) indicateFailure(if (shouldBeTrue) FailureMessages.didNotContainAllElementsOfInOrder(prettifier, left, right) else FailureMessages.containedAllElementsOfInOrder(prettifier, left, right), None, pos) else indicateSuccess(shouldBeTrue, FailureMessages.containedAllElementsOfInOrder(prettifier, left, right), FailureMessages.didNotContainAllElementsOfInOrder(prettifier, left, right)) } /** * This method enables the following syntax: * *
   * map should contain key ("one")
   *                    ^
   * 
**/ infix def key(expectedKey: Any)(implicit keyMapping: KeyMapping[L]): Assertion = { if (keyMapping.containsKey(left, expectedKey) != shouldBeTrue) indicateFailure(if (shouldBeTrue) FailureMessages.didNotContainKey(prettifier, left, expectedKey) else FailureMessages.containedKey(prettifier, left, expectedKey), None, pos) else indicateSuccess(shouldBeTrue, FailureMessages.containedKey(prettifier, left, expectedKey), FailureMessages.didNotContainKey(prettifier, left, expectedKey)) } /** * This method enables the following syntax: * *
   * map should contain value ("one")
   *                    ^
   * 
**/ infix def value(expectedValue: Any)(implicit valueMapping: ValueMapping[L]): Assertion = { if (valueMapping.containsValue(left, expectedValue) != shouldBeTrue) indicateFailure(if (shouldBeTrue) FailureMessages.didNotContainValue(prettifier, left, expectedValue) else FailureMessages.containedValue(prettifier, left, expectedValue), None, pos) else indicateSuccess(shouldBeTrue, FailureMessages.containedValue(prettifier, left, expectedValue), FailureMessages.didNotContainValue(prettifier, left, expectedValue)) } /** * This method enables the following syntax: * *
   * xs should contain atMostOneOf (1, 2)
   *                   ^
   * 
**/ infix def atMostOneOf(firstEle: Any, secondEle: Any, remainingEles: Any*)(implicit aggregating: Aggregating[L]): Assertion = { val right = firstEle :: secondEle :: remainingEles.toList if (right.distinct.size != right.size) throw new NotAllowedException(FailureMessages.atMostOneOfDuplicate, pos) if (aggregating.containsAtMostOneOf(left, right) != shouldBeTrue) indicateFailure( if (shouldBeTrue) FailureMessages.didNotContainAtMostOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) else FailureMessages.containedAtMostOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), None, pos ) else indicateSuccess( shouldBeTrue, FailureMessages.containedAtMostOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))), FailureMessages.didNotContainAtMostOneOf(prettifier, left, UnquotedString(right.map(r => FailureMessages.decorateToStringValue(prettifier, r)).mkString(", "))) ) } /** * This method enables the following syntax: * *
   * xs should contain atMostOneElementOf (1, 2)
   *                   ^
   * 
**/ infix def atMostOneElementOf[R](elements: GenTraversable[R])(implicit aggregating: Aggregating[L]): Assertion = { val right = elements.toList if (aggregating.containsAtMostOneOf(left, right.distinct) != shouldBeTrue) indicateFailure( if (shouldBeTrue) FailureMessages.didNotContainAtMostOneElementOf(prettifier, left, right) else FailureMessages.containedAtMostOneElementOf(prettifier, left, right), None, pos ) else indicateSuccess( shouldBeTrue, FailureMessages.containedAtMostOneElementOf(prettifier, left, right), FailureMessages.didNotContainAtMostOneElementOf(prettifier, left, right) ) } override def toString: String = "ResultOfContainWord(" + Prettifier.default(left) + ", " + Prettifier.default(shouldBeTrue) + ")" }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy