val strAssignment = elements.find { it.lhs.property.name == "str" }
            assertIs<AssignmentTraceElement.RecordedAssignment>(strAssignment)
            val value = resolvedAssignments[strAssignment.lhs]
            assertIs<AssignmentResolver.AssignmentResolutionResult.Assigned>(value)
            val valueOrigin = value.objectOrigin
            assertIs<ObjectOrigin.ConstantOrigin>(valueOrigin)

        )
        val error = result.errors.singleOrNull()
        assertNotNull(error)
        val reason = error.errorReason
        assertIs<ErrorReason.AssignmentTypeMismatch>(reason)
        assertIs<DataType.StringDataType>(reason.expected)
        assertIs<DataType.IntDataType>(reason.actual)
    }

    combinations = testing.parameter_combinations(test_parameters)

    self.assertLen(combinations, 4)
    self.assertIn({'shapes': [3, 3], 'has_bias': True}, combinations)
    self.assertIn({'shapes': [3, 3], 'has_bias': False}, combinations)
    self.assertIn({'shapes': [3, None], 'has_bias': True}, combinations)
    self.assertIn({'shapes': [3, None], 'has_bias': False}, combinations)


class FileSizeTestCase(test.TestCase):

        val additionResults = resolution.assignments.map { impl.addAssignment(it.lhs, it.rhs, it.assignmentMethod, it.operationId.generationId) }
        assertIs<AssignmentResolver.AssignmentAdditionResult.Reassignment>(additionResults[2])

        val resultMap = impl.getAssignmentResults()
        val xAssigned = assertIs<AssignmentResolver.AssignmentResolutionResult.Assigned>(resultMap.entries.single { it.key.property.name == "x" }.value)

			}
		}
		// Passes as expected, but asserting the results.
		if actualErr == nil && testCase.shouldPass {
			expectedResult := testCase.expectedResult
			// Asserting the MaxUploads.
			if actualResult.MaxUploads != expectedResult.MaxUploads {

            resolver
        )

        val call = result.additions.single().dataObject.originElement as FunctionCall
        assertIs<ObjectOrigin.FunctionOrigin>(resolver.trace.expressionResolution(call).result)

        val arg = (call.args.single() as FunctionArgument.Positional).expr
        assertIs<ObjectOrigin.ConstantOrigin>(resolver.trace.expressionResolution(arg).result)
    }

    @Test

        }

        void assertIsTool() {
            assertIs(ProductType.TOOL)
            this.buildConfigurationList.buildConfigurations.each { ProjectFile.PBXTarget.assertNotUnitTestBuildSettings(it.buildSettings) }
        }

        void assertIsDynamicLibrary() {
            assertIs(ProductType.DYNAMIC_LIBRARY)

import kotlin.test.Test
import kotlin.test.assertIs
import kotlin.test.assertTrue


object FunctionExtractorTest {
    @Test
    fun `adding function may have a configuring lambda if it returns the added value`() {
        val schema = schemaFromTypes(ReceiverOne::class, listOf(ReceiverOne::class))
        val function = schema.dataClassesByFqName.values.single().memberFunctions.single()

  }

  public void testBadIpAddresses() {
    for (String spec : BAD_IPS) {
      assertBad(spec);
    }
  }

  public void testGoodDomains() throws ParseException {
    for (String spec : GOOD_DOMAINS) {
      assertGood(spec);
    }
  }

  public void testBadDomains() {
    for (String spec : BAD_DOMAINS) {
      assertBad(spec);
    }
  }

  public void testEquality() {
    new EqualsTester()

        val (rhs1, rhs2) = rhsOrigins

        with(rhs1.assigned) {
            assertIs<ObjectOrigin.NewObjectFromMemberFunction>(this)
            assertEquals("my1", function.simpleName)
        }

        with(rhs2.assigned) {
            assertIs<ObjectOrigin.NewObjectFromMemberFunction>(this)
            assertEquals("my2", function.simpleName)
        }
    }

    @Test