sda-php/nur-ture
11
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

renommer dest en value; tenir compte de la valeur par défaut

Browse Source
This commit is contained in:
Jephté Clain 2025-03-06 16:22:12 +04:00
parent fc523bfb6c
commit 089e4872aa
22 changed files with 448 additions and 411 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/php/access/KeyAccess.php
View File

@ -8,8 +8,8 @@ use nulib\cl;
* Class KeyAccess: accès à une valeur d'une clé dans un tableau
*/
class KeyAccess extends AbstractAccess {
function __construct(&$dest, $key, ?array $params=null) {
$this->dest =& $dest;
function __construct(&$array, $key, ?array $params=null) {
$this->array =& $array;
$this->key = $key;
$this->allowNull = $params["allow_null"] ?? true;
$this->allowFalse = $params["allow_false"] ?? false;
@ -17,10 +17,10 @@ class KeyAccess extends AbstractAccess {
}
/** @var array|ArrayAccess */
protected $dest;
protected $array;
function reset(&$dest): self {
$this->dest =& $dest;
function reset(&$array): self {
$this->array =& $array;
return $this;
}
@ -36,12 +36,12 @@ class KeyAccess extends AbstractAccess {
function exists(): bool {
$key = $this->key;
if ($key === null) return false;
return cl::has($this->dest, $key);
return cl::has($this->array, $key);
}
function available(): bool {
if (!$this->exists()) return false;
$value = cl::get($this->dest, $this->key);
$value = cl::get($this->array, $this->key);
if ($value === null) return $this->allowNull;
if ($value === false) return $this->allowFalse;
if ($value === "") return $this->allowEmpty;
@ -50,7 +50,7 @@ class KeyAccess extends AbstractAccess {
function get($default=null) {
if ($this->key === null) return $default;
$value = cl::get($this->dest, $this->key, $default);
$value = cl::get($this->array, $this->key, $default);
if ($value === null && !$this->allowNull) return $default;
if ($value === false && !$this->allowFalse) return $default;
if ($value === "" && !$this->allowEmpty) return $default;
@ -59,11 +59,11 @@ class KeyAccess extends AbstractAccess {
function set($value): void {
if ($this->key === null) return;
cl::set($this->dest, $this->key, $value);
cl::set($this->array, $this->key, $value);
}
function del(): void {
if ($this->key === null) return;
cl::del($this->dest, $this->key);
cl::del($this->array, $this->key);
}
}

20
src/php/access/ValueAccess.php
View File

@ -5,18 +5,18 @@ namespace nur\sery\wip\php\access;
* Class ValueAccess: accès à une valeur unitaire
*/
class ValueAccess extends AbstractAccess {
function __construct(&$dest, ?array $params=null) {
$this->dest =& $dest;
function __construct(&$value, ?array $params=null) {
$this->value =& $value;
$this->allowNull = $params["allow_null"] ?? false;
$this->allowFalse = $params["allow_false"] ?? true;
$this->allowEmpty = $params["allow_empty"] ?? true;
}
/** @var mixed */
protected $dest;
protected $value;
function reset(&$dest): self {
$this->dest =& $dest;
function reset(&$value): self {
$this->value =& $value;
return $this;
}
@ -27,19 +27,19 @@ class ValueAccess extends AbstractAccess {
protected bool $allowEmpty;
function exists(): bool {
return $this->allowNull || $this->dest !== null;
return $this->allowNull || $this->value !== null;
}
function available(): bool {
if (!$this->exists()) return false;
$value = $this->dest;
$value = $this->value;
if ($value === false) return $this->allowFalse;
if ($value === "") return $this->allowEmpty;
return true;
}
function get($default=null) {
$value = $this->dest;
$value = $this->value;
if ($value === null && !$this->allowNull) return $default;
if ($value === false && !$this->allowFalse) return $default;
if ($value === "" && !$this->allowEmpty) return $default;
@ -47,10 +47,10 @@ class ValueAccess extends AbstractAccess {
}
function set($value): void {
$this->dest = $value;
$this->value = $value;
}
function del(): void {
$this->dest = null;
$this->value = null;
}
}

14
src/schema/AnalyzerContext.php
View File

@ -5,15 +5,15 @@ use nur\sery\wip\schema\input\Input;
use nur\sery\wip\schema\types\IType;
class AnalyzerContext {
function __construct(Schema $schema, Wrapper $wrapper, Input $input, $destKey, Result $result) {
function __construct(Schema $schema, Wrapper $wrapper, Input $input, $valueKey, Result $result) {
$this->schema = $schema;
$this->wrapper = $wrapper;
$this->input = $input;
$this->result = $result;
$this->type = null;
$this->orig = null;
$this->dest = null;
$this->destKey = $destKey;
$this->origValue = null;
$this->value = null;
$this->valueKey = $valueKey;
}
public Schema $schema;
@ -22,9 +22,9 @@ class AnalyzerContext {
public Result $result;
public ?IType $type;
/** @var mixed */
public $orig;
public $origValue;
/** @var mixed */
public $dest;
public $value;
/** @var int|string|null */
public $destKey;
public $valueKey;
}

10
src/schema/Schema.php
View File

@ -39,16 +39,16 @@ abstract class Schema implements ArrayAccess {
/**
* Créer une nouvelle instance de {@link Wrapper} qui référence la
* variable $dest (si $destKey===null) ou $dest[$destKey] si $destKey n'est
* pas null
* variable $value (si $valueKey===null) ou $value[$valueKey] si $valueKey
* n'est pas null
*/
static function nw(&$dest=null, $destKey=null, &$schema=null, $definition=null, ?Wrapper &$destw=null): Wrapper {
static function nw(&$value=null, $valueKey=null, &$schema=null, $definition=null, ?Wrapper &$wrapper=null): Wrapper {
if ($definition === null) {
# bien que techniquement, $definition peut être null (il s'agit alors du
# schéma d'un scalaire quelconque), on ne l'autorise pas ici
throw SchemaException::invalid_schema("definition is required");
}
return self::ns($schema, $definition)->newWrapper($dest, $destKey, $destw);
return self::ns($schema, $definition)->getWrapper($value, $valueKey, $wrapper);
}
/**
@ -70,7 +70,7 @@ abstract class Schema implements ArrayAccess {
/** retourner true si le schéma est de nature scalaire */
function isScalar(?ScalarSchema &$scalar=null): bool { return false; }
abstract function newWrapper(&$dest=null, $destKey=null, ?Wrapper &$destw=null): Wrapper;
abstract function getWrapper(&$value=null, $valueKey=null, ?Wrapper &$wrapper=null): Wrapper;
#############################################################################
# key & properties

15
src/schema/TODO.md
View File

@ -1,7 +1,6 @@
# nulib\schema
* tenir compte de la valeur par défaut, qui *doit* être du bon type
* newInput dans Schema
* tester type===null --> implémenter traw et tmixed
* ScalarSchema::from_property()
* dans AssocSchema, support `[key_prefix]` qui permet de spécifier un préfixe
@ -11,11 +10,11 @@
"a" => "?string",
"b" => "?int",
])->newWrapper();
$dest = ["x_a" => 5, "x_b" => "10"],
$wrapper->reset($dest, null, [
$value = ["x_a" => 5, "x_b" => "10"],
$wrapper->reset($value, null, [
"key_prefix" => "x_",
]);
# $dest vaut ["x_a" => "5", "x_b" => 10];
# $value vaut ["x_a" => "5", "x_b" => 10];
~~~
définir si le préfixe doit être spécifié sur le schéma ou sur la valeur...
actuellement, le code ne permet pas de définir de tels paramètres...
@ -29,9 +28,9 @@
], [
"key_prefix" => "x_",
])->newWrapper();
$dest = ["x_a" => 5, "x_b" => "10"],
$wrapper->reset($dest);
# $dest vaut ["x_a" => "5", "x_b" => 10];
$value = ["x_a" => 5, "x_b" => "10"],
$wrapper->reset($value);
# $value vaut ["x_a" => "5", "x_b" => 10];
~~~
* implémenter l'instanciation de types avec des paramètres particuliers. *si*
des paramètres sont fournis, le type est instancié avec la signature

2
src/schema/Wrapper.php
View File

@ -14,7 +14,7 @@ abstract class Wrapper implements ArrayAccess, IteratorAggregate {
function isScalar(?ScalarWrapper &$scalar=null): bool { return false; }
/** spécifier la valeur destination gérée par cet objet */
abstract function reset(&$dest, $destKey=null, ?bool $verifix=null): self;
abstract function reset(&$value, $valueKey=null, ?bool $verifix=null): self;
/**
* Obtenir la liste des clés valides pour les valeurs accessibles via cet

6
src/schema/_assoc/AssocSchema.php
View File

@ -48,8 +48,8 @@ class AssocSchema extends Schema {
return true;
}
function newWrapper(&$dest=null, $destKey=null, ?Wrapper &$destw=null): AssocWrapper {
if ($destw instanceof AssocWrapper) return $destw->reset($dest, $destKey);
else return ($destw = new AssocWrapper($this, $dest, $destKey));
function getWrapper(&$value=null, $valueKey=null, ?Wrapper &$wrapper=null): AssocWrapper {
if ($wrapper instanceof AssocWrapper) return $wrapper->reset($value, $valueKey);
else return ($wrapper = new AssocWrapper($this, $value, $valueKey));
}
}

6
src/schema/_list/ListSchema.php
View File

@ -46,8 +46,8 @@ class ListSchema extends Schema {
return true;
}
function newWrapper(&$dest=null, $destKey=null, ?Wrapper &$destw=null): ListWrapper {
if ($destw instanceof ListWrapper) return $destw->reset($dest, $destKey);
else return ($destw = new ListWrapper($this, $dest, $destKey));
function getWrapper(&$value=null, $valueKey=null, ?Wrapper &$wrapper=null): ListWrapper {
if ($wrapper instanceof ListWrapper) return $wrapper->reset($value, $valueKey);
else return ($wrapper = new ListWrapper($this, $value, $valueKey));
}
}

9
src/schema/_scalar/ScalarSchema.php
View File

@ -7,6 +7,7 @@ use nulib\ref\schema\ref_types;
use nur\sery\wip\schema\Schema;
use nur\sery\wip\schema\SchemaException;
use nur\sery\wip\schema\types;
use nur\sery\wip\schema\types\IType;
use nur\sery\wip\schema\types\tarray;
use nur\sery\wip\schema\types\tbool;
use nur\sery\wip\schema\types\tcallable;
@ -18,7 +19,7 @@ use nur\sery\wip\schema\Wrapper;
/**
* Class ScalarSchema
*
* @property-read array $type
* @property-read array|IType $type
* @property-read mixed $default
* @property-read string|null $title
* @property-read bool $required
@ -193,9 +194,9 @@ class ScalarSchema extends Schema {
return true;
}
function newWrapper(&$dest=null, $destKey=null, ?Wrapper &$destw=null): ScalarWrapper {
if ($destw instanceof ScalarWrapper) return $destw->reset($dest, $destKey);
else return ($destw = new ScalarWrapper($this, $dest, $destKey));
function getWrapper(&$value=null, $valueKey=null, ?Wrapper &$wrapper=null): ScalarWrapper {
if ($wrapper instanceof ScalarWrapper) return $wrapper->reset($value, $valueKey);
else return ($wrapper = new ScalarWrapper($this, $value, $valueKey));
}
#############################################################################

96
src/schema/_scalar/ScalarWrapper.php
View File

@ -9,14 +9,13 @@ use nur\sery\wip\schema\input\Input;
use nur\sery\wip\schema\types;
use nur\sery\wip\schema\types\IType;
use nur\sery\wip\schema\Wrapper;
use PHPUnit\Event\Code\Throwable;
class ScalarWrapper extends Wrapper {
function __construct(ScalarSchema $schema, &$dest=null, $destKey=null, ?array $params=null) {
function __construct(ScalarSchema $schema, &$value=null, $valueKey=null, ?array $params=null) {
$verifix = $params["verifix"] ?? true;
$throw = $params["throw"] ?? null;
if ($dest !== null && $throw === null) {
# Si $dest est null, ne pas lancer d'exception, parce qu'on considère que
if ($value !== null && $throw === null) {
# Si $value est null, ne pas lancer d'exception, parce qu'on considère que
# c'est une initialisation sans conséquences
$throw = true;
}
@ -24,7 +23,7 @@ class ScalarWrapper extends Wrapper {
$this->verifix = $verifix;
$this->throw = $throw ?? false;
$this->result = new ScalarResult();
$this->reset($dest, $destKey);
$this->reset($value, $valueKey);
$this->throw = $throw ?? true;
}
@ -37,7 +36,7 @@ class ScalarWrapper extends Wrapper {
protected Input $input;
/** @var string|int|null clé de la valeur dans le tableau destination */
protected $destKey;
protected $valueKey;
protected bool $verifix;
@ -49,11 +48,15 @@ class ScalarWrapper extends Wrapper {
/** résultat de l'analyse de la valeur */
protected ScalarResult $result;
function reset(&$dest, $destKey=null, ?bool $verifix=null): Wrapper {
if ($dest instanceof Input) $input = $dest;
else $input = new Input($dest);
protected function newInput(&$value): Input {
return new Input($value);
}
function reset(&$value, $valueKey=null, ?bool $verifix=null): Wrapper {
if ($value instanceof Input) $input = $value;
else $input = $this->newInput($value);
$this->input = $input;
$this->destKey = $destKey;
$this->valueKey = $valueKey;
$this->type = null;
$this->analyzeExtractParse();
if ($verifix ?? $this->verifix) $this->verifix();
@ -74,11 +77,19 @@ class ScalarWrapper extends Wrapper {
/** @var ScalarSchema $schema */
$schema = $context->schema;
$input = $context->input;
$destKey = $context->destKey;
$valueKey = $context->valueKey;
/** @var ScalarResult $result */
$result = $context->result;
if (!$input->isPresent($destKey)) return $result->setMissing($schema);
$default = $schema->default;
if (!$input->isPresent($valueKey)) {
if ($default !== null) {
$input->set($default, $valueKey);
return $result->setNormalized();
} else {
return $result->setMissing($schema);
}
}
$schemaTypes = $schema->type;
if ($schemaTypes instanceof IType) {
@ -103,9 +114,9 @@ class ScalarWrapper extends Wrapper {
$type = types::get($schema->nullable, $name, $params, $this->schema->getDefinition());
if ($firstType === null) $firstType = $type;
$types[] = $type;
if ($type->isAvailable($input, $destKey)) {
if ($type->isAvailable($input, $valueKey)) {
if (!$haveValue) {
$value = $input->get($destKey);
$value = $input->get($valueKey);
$haveValue = true;
}
if ($type->isValid($value, $normalized) && $normalized) {
@ -117,7 +128,7 @@ class ScalarWrapper extends Wrapper {
# ensuite chercher un type pour lequel la valeur est valide
if (!$haveType) {
foreach ($types as $type) {
if ($type->isAvailable($input, $destKey) && $type->isValid($value)) {
if ($type->isAvailable($input, $valueKey) && $type->isValid($value)) {
$haveType = true;
break;
}
@ -130,10 +141,17 @@ class ScalarWrapper extends Wrapper {
}
$context->type = $this->type = $type;
if (!$type->isAvailable($input, $destKey)) return $result->setUnavailable($schema);
if (!$type->isAvailable($input, $valueKey)) {
if ($default !== null) {
$input->set($default, $valueKey);
return $result->setNormalized();
} else {
return $result->setUnavailable($schema);
}
}
$value = $input->get($destKey);
$context->orig = $context->dest = $value;
$value = $input->get($valueKey);
$context->origValue = $context->value = $value;
if ($type->isNull($value)) {
return $result->setNull($schema);
} elseif (is_string($value)) {
@ -149,10 +167,10 @@ class ScalarWrapper extends Wrapper {
function analyzeExtractParse(): int {
$schema = $this->schema;
$input = $this->input;
$destKey = $this->destKey;
$valueKey = $this->valueKey;
$result = $this->result;
$result->reset();
$context = new AnalyzerContext($schema, $this, $input, $destKey, $result);
$context = new AnalyzerContext($schema, $this, $input, $valueKey, $result);
/** @var func $analyzerFunc */
$analyzerFunc = $schema->analyzerFunc;
@ -160,15 +178,15 @@ class ScalarWrapper extends Wrapper {
else $what = $this->_analyze($context);
if ($what !== ref_analyze::STRING) return $what;
$dest = $context->dest;
$value = $context->value;
try {
/** @var func $extractorFunc */
$extractorFunc = $schema->extractorFunc;
if ($extractorFunc !== null) $extracted = $extractorFunc->invoke([$dest, $context]);
else $extracted = $context->type->extract($dest);
$context->dest = $extracted;
if ($extractorFunc !== null) $extracted = $extractorFunc->invoke([$value, $context]);
else $extracted = $context->type->extract($value);
$context->value = $extracted;
} catch (ValueException $e) {
return $result->setInvalid($context->orig, $schema, $e);
return $result->setInvalid($context->origValue, $schema, $e);
}
if ($context->type->isNull($extracted)) return $result->setNull($schema);
@ -177,31 +195,31 @@ class ScalarWrapper extends Wrapper {
$parserFunc = $schema->parserFunc;
if ($parserFunc !== null) $parsed = $parserFunc->invoke([$extracted, $context]);
else $parsed = $context->type->parse($extracted);
$context->dest = $parsed;
$context->value = $parsed;
} catch (ValueException $e) {
return $result->setInvalid($context->orig, $schema, $e);
return $result->setInvalid($context->origValue, $schema, $e);
}
$normalized = $parsed === $context->orig;
$normalized = $parsed === $context->origValue;
if ($normalized) {
$input->set($parsed, $destKey);
$input->set($parsed, $valueKey);
return $result->setNormalized();
} else {
$input->set($extracted, $destKey);
$input->set($extracted, $valueKey);
return $result->setValid($parsed);
}
}
function verifix(?bool $throw=null): bool {
$result = $this->result;
$destKey = $this->destKey;
$valueKey = $this->valueKey;
$verifix = false;
$modified = false;
if ($result->resultAvailable) {
if ($result->null) {
# forcer la valeur null, parce que la valeur actuelle est peut-être une
# valeur assimilée à null
$this->input->set(null, $destKey);
$this->input->set(null, $valueKey);
} elseif ($result->valid && !$result->normalized) {
$normalizedValue = $result->normalizedValue;
if ($normalizedValue !== null) {
@ -219,19 +237,19 @@ class ScalarWrapper extends Wrapper {
}
if ($verifix) {
$value = $this->input->get($destKey);
$value = $this->input->get($valueKey);
$schema = $this->schema;
/** @var func $normalizerFunc */
$normalizerFunc = $schema->normalizerFunc;
if ($normalizerFunc !== null) {
$context = new AnalyzerContext($schema, $this, $this->input, $destKey, $result);
$context = new AnalyzerContext($schema, $this, $this->input, $valueKey, $result);
$orig = $value;
$value = $normalizerFunc->invoke([$orig, $context]);
$modified = $value !== $orig;
} else {
$modified = $this->type->verifix($value, $result, $this->schema);
}
if ($result->valid) $this->input->set($value, $destKey);
if ($result->valid) $this->input->set($value, $valueKey);
}
if (!$result->valid) $result->throw($throw ?? $this->throw);
return $modified;
@ -262,26 +280,26 @@ class ScalarWrapper extends Wrapper {
}
function get($default=null) {
if ($this->result->available) return $this->input->get($this->destKey);
if ($this->result->available) return $this->input->get($this->valueKey);
else return $default;
}
function set($value, ?bool $verifix=null): ScalarWrapper {
$this->input->set($value, $this->destKey);
$this->input->set($value, $this->valueKey);
$this->analyzeExtractParse();
if ($verifix ?? $this->verifix) $this->verifix();
return $this;
}
function unset(?bool $verifix=null): ScalarWrapper {
$this->input->unset($this->destKey);
$this->input->unset($this->valueKey);
$this->analyzeExtractParse();
if ($verifix ?? $this->verifix) $this->verifix();
return $this;
}
function format($format=null): string {
$value = $this->input->get($this->destKey);
$value = $this->input->get($this->valueKey);
/** @var func $formatterFunc */
$formatterFunc = $this->schema->formatterFunc;
if ($formatterFunc !== null) {

2
src/schema/input/FormInput.php
View File

@ -25,7 +25,7 @@ class FormInput extends Input {
}
protected function access($key): IAccess {
return $this->keyAccess[$key] ??= new ShadowAccess($this->formAccess($key), new KeyAccess($this->dest, $key, [
return $this->keyAccess[$key] ??= new ShadowAccess($this->formAccess($key), new KeyAccess($this->value, $key, [
"allow_empty" => $this->allowEmpty,
]));
}

10
src/schema/input/Input.php
View File

@ -13,13 +13,13 @@ use nur\sery\wip\php\access\ValueAccess;
class Input {
const ALLOW_EMPTY = true;
function __construct(&$dest=null, ?array $params=null) {
$this->dest =& $dest;
function __construct(&$value=null, ?array $params=null) {
$this->value =& $value;
$this->allowEmpty = $params["allow_empty"] ?? static::ALLOW_EMPTY;
}
/** @var mixed */
protected $dest;
protected $value;
/**
* @var bool comment considérer une chaine vide: "" si allowEmpty, null sinon
@ -31,12 +31,12 @@ class Input {
protected function access($key): IAccess {
if ($key === null) {
return $this->valueAccess ??= new ValueAccess($this->dest, [
return $this->valueAccess ??= new ValueAccess($this->value, [
"allow_null" => true,
"allow_empty" => $this->allowEmpty,
]);
} else {
return $this->keyAccess[$key] ??= new KeyAccess($this->dest, $key, [
return $this->keyAccess[$key] ??= new KeyAccess($this->value, $key, [
"allow_empty" => $this->allowEmpty,
]);
}

1
src/schema/types.php
View File

@ -9,6 +9,7 @@ use nur\sery\wip\schema\types\tcallable;
use nur\sery\wip\schema\types\tfloat;
use nur\sery\wip\schema\types\tint;
use nur\sery\wip\schema\types\trawstring;
use nur\sery\wip\schema\types\tstring;
use nur\sery\wip\schema\types\ttext;
/**

4
src/schema/types/IType.php
View File

@ -58,8 +58,8 @@ interface IType {
*/
function get3States(): array;
/** la donnée $input($destKey) est-elle disponible? */
function isAvailable(Input $input, $destKey): bool;
/** la donnée $input($valueKey) est-elle disponible? */
function isAvailable(Input $input, $valueKey): bool;
/** la valeur $value est-elle nulle? */
function isNull($value): bool;

4
src/schema/types/_tsimple.php
View File

@ -39,8 +39,8 @@ abstract class _tsimple implements IType {
throw StateException::not_implemented();
}
function isAvailable(Input $input, $destKey): bool {
return $input->isAvailable($destKey) && $input->get($destKey) !== false;
function isAvailable(Input $input, $valueKey): bool {
return $input->isAvailable($valueKey) && $input->get($valueKey) !== false;
}
function isNull($value): bool {

4
src/schema/types/tbool.php
View File

@ -72,8 +72,8 @@ class tbool extends _tformatable {
return [false, true, null];
}
function isAvailable(Input $input, $destKey): bool {
return $input->isAvailable($destKey);
function isAvailable(Input $input, $valueKey): bool {
return $input->isAvailable($valueKey);
}
function isValid($value, ?bool &$normalized=null): bool {

33
tests/wip/schema/_scalar/ScalarValueTest.php
View File

@ -6,16 +6,16 @@ use nulib\ValueException;
use nur\sery\wip\schema\input\Input;
class ScalarValueTest extends TestCase {
function checkValue(ScalarWrapper $value, $dest, bool $present, bool $available, bool $valid, bool $normalized): void {
self::assertSame($dest, $value->get(), "value");
self::assertSame($present, $value->isPresent(), "present");
self::assertSame($available, $value->isAvailable(), "available");
self::assertSame($valid, $value->isValid(), "valid");
self::assertSame($normalized, $value->isNormalized(), "normalized");
function checkValue(ScalarWrapper $wrapper, $dest, bool $present, bool $available, bool $valid, bool $normalized): void {
self::assertSame($dest, $wrapper->get(), "value");
self::assertSame($present, $wrapper->isPresent(), "present");
self::assertSame($available, $wrapper->isAvailable(), "available");
self::assertSame($valid, $wrapper->isValid(), "valid");
self::assertSame($normalized, $wrapper->isNormalized(), "normalized");
}
function checkVerifix(ScalarSchema $schema, $src, bool $verifix, $dest, bool $present, bool $available, bool $valid, bool $normalized, ?array $inputParams=null): void {
$value = $schema->newWrapper();
$value = $schema->getWrapper();
if ($inputParams !== null) $input = new Input($src, $inputParams);
else $input = $src;
$value->reset($input, null, $verifix);
@ -23,7 +23,7 @@ class ScalarValueTest extends TestCase {
}
function checkException(ScalarSchema $schema, $src, bool $verifix, string $exceptionClass, ?array $inputParams=null) {
$value = $schema->newWrapper();
$value = $schema->getWrapper();
if ($inputParams !== null) $src = new Input($src, $inputParams);
self::assertException($exceptionClass, function() use ($value, &$src, $verifix) {
$value->reset($src, null, $verifix);
@ -60,6 +60,23 @@ class ScalarValueTest extends TestCase {
$this->checkVerifix($schema, [], false, [], true, true, false, false);
$this->checkException($schema, [], true, ValueException::class);
## Tester valeur par défaut
$schema = new ScalarSchema(["rawstring", null]);
$this->checkVerifix($schema, false, false, null, true, false, true, true);
$this->checkVerifix($schema, false, true, null, true, false, true, true);
$this->checkVerifix($schema, null, false, null, true, true, false, false);
$this->checkException($schema, null, true, ValueException::class);
$schema = new ScalarSchema(["rawstring", "default"]);
$this->checkVerifix($schema, false, false, "default", true, true, true, true);
$this->checkVerifix($schema, false, true, "default", true, true, true, true);
$this->checkVerifix($schema, null, false, null, true, true, false, false);
$this->checkException($schema, null, true, ValueException::class);
## Tester nullable
$schema = new ScalarSchema("?rawstring");

144
tests/wip/schema/types/boolTest.php
View File

@ -7,105 +7,105 @@ use nur\sery\wip\schema\_scalar\ScalarWrapper;
use nur\sery\wip\schema\Schema;
class boolTest extends TestCase {
function commonTests($destv, &$dest, callable $destvSetter): void {
$destv->set(true);
self::assertSame(true, $destv->get());
self::assertSame(true, $dest);
self::assertSame("Oui", $destv->format());
self::assertSame("Oui", $destv->format("OuiNonNull"));
self::assertSame("O", $destv->format("ON"));
self::assertSame("O", $destv->format("ONN"));
function commonTests($wrapper, &$value, callable $wrapperSetter): void {
$wrapper->set(true);
self::assertSame(true, $wrapper->get());
self::assertSame(true, $value);
self::assertSame("Oui", $wrapper->format());
self::assertSame("Oui", $wrapper->format("OuiNonNull"));
self::assertSame("O", $wrapper->format("ON"));
self::assertSame("O", $wrapper->format("ONN"));
$destv->set(false);
self::assertSame(false, $destv->get());
self::assertSame(false, $dest);
self::assertSame("Non", $destv->format());
self::assertSame("Non", $destv->format("OuiNonNull"));
self::assertSame("N", $destv->format("ON"));
self::assertSame("N", $destv->format("ONN"));
$wrapper->set(false);
self::assertSame(false, $wrapper->get());
self::assertSame(false, $value);
self::assertSame("Non", $wrapper->format());
self::assertSame("Non", $wrapper->format("OuiNonNull"));
self::assertSame("N", $wrapper->format("ON"));
self::assertSame("N", $wrapper->format("ONN"));
$destv->set("yes");
self::assertSame(true, $destv->get());
$wrapper->set("yes");
self::assertSame(true, $wrapper->get());
$destv->set(" yes ");
self::assertSame(true, $destv->get());
$wrapper->set(" yes ");
self::assertSame(true, $wrapper->get());
$destv->set("12");
self::assertSame(true, $destv->get());
$wrapper->set("12");
self::assertSame(true, $wrapper->get());
$destv->set(12);
self::assertSame(true, $destv->get());
$wrapper->set(12);
self::assertSame(true, $wrapper->get());
$destv->set("no");
self::assertSame(false, $destv->get());
$wrapper->set("no");
self::assertSame(false, $wrapper->get());
$destv->set(" no ");
self::assertSame(false, $destv->get());
$wrapper->set(" no ");
self::assertSame(false, $wrapper->get());
$destv->set("0");
self::assertSame(false, $destv->get());
$wrapper->set("0");
self::assertSame(false, $wrapper->get());
$destv->set(0);
self::assertSame(false, $destv->get());
$wrapper->set(0);
self::assertSame(false, $wrapper->get());
$destv->set(12.34);
self::assertSame(true, $destv->get());
$wrapper->set(12.34);
self::assertSame(true, $wrapper->get());
self::assertException(Exception::class, $destvSetter("a"));
self::assertException(Exception::class, $destvSetter([]));
self::assertException(Exception::class, $destvSetter(["a"]));
self::assertException(Exception::class, $wrapperSetter("a"));
self::assertException(Exception::class, $wrapperSetter([]));
self::assertException(Exception::class, $wrapperSetter(["a"]));
}
function testBool() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, "bool", $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, "bool", $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
self::assertException(Exception::class, $destvSetter(null));
self::assertException(Exception::class, $destvSetter(""));
self::assertException(Exception::class, $destvSetter(" "));
self::assertException(Exception::class, $wrapperSetter(null));
self::assertException(Exception::class, $wrapperSetter(""));
self::assertException(Exception::class, $wrapperSetter(" "));
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
function testNbool() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, "?bool", $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, "?bool", $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
$destv->set(null);
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("Non", $destv->format());
self::assertSame("", $destv->format("OuiNonNull"));
self::assertSame("N", $destv->format("ON"));
self::assertSame("", $destv->format("ONN"));
$wrapper->set(null);
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("Non", $wrapper->format());
self::assertSame("", $wrapper->format("OuiNonNull"));
self::assertSame("N", $wrapper->format("ON"));
self::assertSame("", $wrapper->format("ONN"));
$destv->set("");
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("Non", $destv->format());
self::assertSame("", $destv->format("OuiNonNull"));
self::assertSame("N", $destv->format("ON"));
self::assertSame("", $destv->format("ONN"));
$wrapper->set("");
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("Non", $wrapper->format());
self::assertSame("", $wrapper->format("OuiNonNull"));
self::assertSame("N", $wrapper->format("ON"));
self::assertSame("", $wrapper->format("ONN"));
$destv->set(" ");
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("Non", $destv->format());
self::assertSame("", $destv->format("OuiNonNull"));
self::assertSame("N", $destv->format("ON"));
self::assertSame("", $destv->format("ONN"));
$wrapper->set(" ");
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("Non", $wrapper->format());
self::assertSame("", $wrapper->format("OuiNonNull"));
self::assertSame("N", $wrapper->format("ON"));
self::assertSame("", $wrapper->format("ONN"));
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
}

158
tests/wip/schema/types/floatTest.php
View File

@ -7,133 +7,133 @@ use nur\sery\wip\schema\_scalar\ScalarWrapper;
use nur\sery\wip\schema\Schema;
class floatTest extends TestCase {
function commonTests($destv, &$dest, callable $destvSetter): void {
$destv->set(12);
self::assertSame(12.0, $destv->get());
self::assertSame(12.0, $dest);
self::assertSame("12", $destv->format());
self::assertSame("0012", $destv->format("%04u"));
function commonTests($wrapper, &$value, callable $wrapperSetter): void {
$wrapper->set(12);
self::assertSame(12.0, $wrapper->get());
self::assertSame(12.0, $value);
self::assertSame("12", $wrapper->format());
self::assertSame("0012", $wrapper->format("%04u"));
$destv->set("12");
self::assertSame(12.0, $destv->get());
$wrapper->set("12");
self::assertSame(12.0, $wrapper->get());
$destv->set(" 12 ");
self::assertSame(12.0, $destv->get());
$wrapper->set(" 12 ");
self::assertSame(12.0, $wrapper->get());
$destv->set(12.34);
self::assertSame(12.34, $destv->get());
$wrapper->set(12.34);
self::assertSame(12.34, $wrapper->get());
$destv->set(true);
self::assertSame(1.0, $destv->get());
$wrapper->set(true);
self::assertSame(1.0, $wrapper->get());
self::assertException(Exception::class, $destvSetter("a"));
self::assertException(Exception::class, $destvSetter([]));
self::assertException(Exception::class, $destvSetter(["a"]));
self::assertException(Exception::class, $wrapperSetter("a"));
self::assertException(Exception::class, $wrapperSetter([]));
self::assertException(Exception::class, $wrapperSetter(["a"]));
}
function testFloat() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, "float", $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, "float", $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
self::assertException(Exception::class, $destvSetter(null));
self::assertException(Exception::class, $destvSetter(""));
self::assertException(Exception::class, $destvSetter(" "));
self::assertException(Exception::class, $wrapperSetter(null));
self::assertException(Exception::class, $wrapperSetter(""));
self::assertException(Exception::class, $wrapperSetter(" "));
// valeur non requise donc retourne null
$destv->set(false);
self::assertNull($destv->get());
$wrapper->set(false);
self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
function testRequiredFloat() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, [
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, [
"float", null,
"required" => true,
], $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
], $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
self::assertException(Exception::class, $destvSetter(null));
self::assertException(Exception::class, $destvSetter(""));
self::assertException(Exception::class, $destvSetter(" "));
self::assertException(Exception::class, $wrapperSetter(null));
self::assertException(Exception::class, $wrapperSetter(""));
self::assertException(Exception::class, $wrapperSetter(" "));
// valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false));
self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
function testNfloat() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, "?float", $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, "?float", $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
$destv->set(null);
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set(null);
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
$destv->set("");
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set("");
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
$destv->set(" ");
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set(" ");
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
// valeur non requise donc retourne null
$destv->set(false);
self::assertNull($destv->get());
$wrapper->set(false);
self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
function testRequiredNfloat() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, [
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, [
"?float", null,
"required" => true,
], $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
], $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
$destv->set(null);
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set(null);
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
$destv->set("");
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set("");
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
$destv->set(" ");
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set(" ");
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
// valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false));
self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
}

158
tests/wip/schema/types/intTest.php
View File

@ -7,133 +7,133 @@ use nur\sery\wip\schema\_scalar\ScalarWrapper;
use nur\sery\wip\schema\Schema;
class intTest extends TestCase {
function commonTests($destv, &$dest, callable $destvSetter): void {
$destv->set(12);
self::assertSame(12, $destv->get());
self::assertSame(12, $dest);
self::assertSame("12", $destv->format());
self::assertSame("0012", $destv->format("%04u"));
function commonTests($wrapper, &$value, callable $wrapperSetter): void {
$wrapper->set(12);
self::assertSame(12, $wrapper->get());
self::assertSame(12, $value);
self::assertSame("12", $wrapper->format());
self::assertSame("0012", $wrapper->format("%04u"));
$destv->set("12");
self::assertSame(12, $destv->get());
$wrapper->set("12");
self::assertSame(12, $wrapper->get());
$destv->set(" 12 ");
self::assertSame(12, $destv->get());
$wrapper->set(" 12 ");
self::assertSame(12, $wrapper->get());
$destv->set(12.34);
self::assertSame(12, $destv->get());
$wrapper->set(12.34);
self::assertSame(12, $wrapper->get());
$destv->set(true);
self::assertSame(1, $destv->get());
$wrapper->set(true);
self::assertSame(1, $wrapper->get());
self::assertException(Exception::class, $destvSetter("a"));
self::assertException(Exception::class, $destvSetter([]));
self::assertException(Exception::class, $destvSetter(["a"]));
self::assertException(Exception::class, $wrapperSetter("a"));
self::assertException(Exception::class, $wrapperSetter([]));
self::assertException(Exception::class, $wrapperSetter(["a"]));
}
function testInt() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, "int", $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, "int", $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
self::assertException(Exception::class, $destvSetter(null));
self::assertException(Exception::class, $destvSetter(""));
self::assertException(Exception::class, $destvSetter(" "));
self::assertException(Exception::class, $wrapperSetter(null));
self::assertException(Exception::class, $wrapperSetter(""));
self::assertException(Exception::class, $wrapperSetter(" "));
// valeur non requise donc retourne null
$destv->set(false);
self::assertNull($destv->get());
$wrapper->set(false);
self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
function testRequiredInt() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, [
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, [
"int", null,
"required" => true,
], $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
], $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
self::assertException(Exception::class, $destvSetter(null));
self::assertException(Exception::class, $destvSetter(""));
self::assertException(Exception::class, $destvSetter(" "));
self::assertException(Exception::class, $wrapperSetter(null));
self::assertException(Exception::class, $wrapperSetter(""));
self::assertException(Exception::class, $wrapperSetter(" "));
// valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false));
self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
function testNint() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, "?int", $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, "?int", $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
$destv->set(null);
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set(null);
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
$destv->set("");
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set("");
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
$destv->set(" ");
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set(" ");
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
// valeur non requise donc retourne null
$destv->set(false);
self::assertNull($destv->get());
$wrapper->set(false);
self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
function testRequiredNint() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, [
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, [
"?int", null,
"required" => true,
], $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
], $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
$destv->set(null);
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set(null);
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
$destv->set("");
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set("");
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
$destv->set(" ");
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set(" ");
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
// valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false));
self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
}

128
tests/wip/schema/types/strTest.php
View File

@ -7,117 +7,117 @@ use nur\sery\wip\schema\_scalar\ScalarWrapper;
use nur\sery\wip\schema\Schema;
class strTest extends TestCase {
function commonTests($destv, &$dest, callable $destvSetter): void {
$destv->set("");
self::assertSame("", $destv->get());
self::assertSame("", $dest);
function commonTests($wrapper, &$value, callable $wrapperSetter): void {
$wrapper->set("");
self::assertSame("", $wrapper->get());
self::assertSame("", $value);
$destv->set(" ");
self::assertSame("", $destv->get());
self::assertSame("", $dest);
$wrapper->set(" ");
self::assertSame("", $wrapper->get());
self::assertSame("", $value);
$destv->set("a");
self::assertSame("a", $destv->get());
self::assertSame("a", $dest);
$wrapper->set("a");
self::assertSame("a", $wrapper->get());
self::assertSame("a", $value);
$destv->set("12");
self::assertSame("12", $destv->get());
$wrapper->set("12");
self::assertSame("12", $wrapper->get());
$destv->set(" 12 ");
self::assertSame("12", $destv->get());
$wrapper->set(" 12 ");
self::assertSame("12", $wrapper->get());
$destv->set(12);
self::assertSame("12", $destv->get());
$wrapper->set(12);
self::assertSame("12", $wrapper->get());
$destv->set(12.34);
self::assertSame("12.34", $destv->get());
$wrapper->set(12.34);
self::assertSame("12.34", $wrapper->get());
$destv->set(true);
self::assertSame("1", $destv->get());
$wrapper->set(true);
self::assertSame("1", $wrapper->get());
self::assertException(Exception::class, $destvSetter([]));
self::assertException(Exception::class, $destvSetter(["a"]));
self::assertException(Exception::class, $wrapperSetter([]));
self::assertException(Exception::class, $wrapperSetter(["a"]));
}
function testStr() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, "string", $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, "string", $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
self::assertException(Exception::class, $destvSetter(null));
self::assertException(Exception::class, $wrapperSetter(null));
// valeur non requise donc retourne null
$destv->set(false);
self::assertNull($destv->get());
$wrapper->set(false);
self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
function testRequiredStr() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, [
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, [
"string", null,
"required" => true,
], $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
], $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
self::assertException(Exception::class, $destvSetter(null));
self::assertException(Exception::class, $wrapperSetter(null));
// valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false));
self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
function testNstr() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, "?string", $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, "?string", $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
$destv->set(null);
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set(null);
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
// valeur non requise donc retourne null
$destv->set(false);
self::assertNull($destv->get());
$wrapper->set(false);
self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
function testRequiredNstr() {
/** @var ScalarWrapper $destv */
Schema::nw($dest, null, $schema, [
/** @var ScalarWrapper $wrapper */
Schema::nw($value, null, $schema, [
"?string", null,
"required" => true,
], $destv);
$destvSetter = function($value) use($destv) {
return function() use($destv, $value) {
$destv->set($value);
], $wrapper);
$wrapperSetter = function($value) use($wrapper) {
return function() use($wrapper, $value) {
$wrapper->set($value);
};
};
$destv->set(null);
self::assertNull($destv->get());
self::assertNull($dest);
self::assertSame("", $destv->format());
$wrapper->set(null);
self::assertNull($wrapper->get());
self::assertNull($value);
self::assertSame("", $wrapper->format());
// valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false));
self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter);
$this->commonTests($wrapper, $value, $wrapperSetter);
}
}

15
tests/wip/schema/types/unionTest.php
View File

@ -10,20 +10,21 @@ class unionTest extends TestCase {
## l'ordre des types doit être respecté
# string puis int
/** @var ScalarWrapper $siv */
Schema::nw($si, null, $sis, "string|int", $siv);
/** @var ScalarWrapper $siw */
Schema::nw($si, null, $sis, "string|int", $siw);
$siv->set("12");
$siw->set("12");
self::assertSame("12", $si);
$siv->set(12);
$siw->set(12);
self::assertSame(12, $si);
# int puis string
Schema::nw($is, null, $iss, "int|string", $isv);
/** @var ScalarWrapper $isw */
Schema::nw($is, null, $iss, "int|string", $isw);
$isv->set("12");
$isw->set("12");
self::assertSame("12", $is);
$isv->set(12);
$isw->set(12);
self::assertSame(12, $is);
}
}