cadmpeg-ir 0.6.1

CAD data model, validation, diffing, and codec API for cadmpeg.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

// SPDX-License-Identifier: Apache-2.0
use crate::geometry::pcurve::PcurveNurbs;
use crate::math::Point2;
use crate::sketches::{SketchGeometry, SketchGeometryDefinition};
use cadmpeg_core::decode::{DecodeArena, DecodeContext, DecodePolicy, ResourceDimension};
use cadmpeg_core::text::NonBlankString;
use cadmpeg_core::CodecError;

fn copy_with_policy(
    geometry: &SketchGeometry,
    policy: &DecodePolicy,
) -> Result<SketchGeometry, CodecError> {
    let arena = DecodeArena::new();
    let (ctx, _) = DecodeContext::from_root_bytes(&[], &arena, policy).expect("empty root");
    geometry.try_clone_for_decode(&ctx, "sketch geometry copy")
}

#[test]
fn sketch_nurbs_copy_refuses_each_nested_collection() {
    let curve = PcurveNurbs::from_lanes(
        &cadmpeg_test_support::service_decode_context(),
        1,
        vec![0.0, 0.0, 1.0, 1.0],
        vec![Point2::new(0.0, 0.0), Point2::new(1.0, 0.0)],
        None,
        false,
    )
    .expect("fixture pcurve construction admission")
    .expect("linear NURBS fixture");
    let geometry = SketchGeometry::nurbs(curve);
    let mut policy = DecodePolicy::service();
    policy.limits.max_collection_items = 0;
    let error = copy_with_policy(&geometry, &policy).expect_err("four knots exceed zero items");
    assert!(matches!(error, CodecError::ResourceLimit(resource)
        if resource.dimension == ResourceDimension::CollectionItems
            && resource.operation == "sketch geometry copy"));
    policy.limits.max_collection_items = 4;
    let error = copy_with_policy(&geometry, &policy).expect_err("two poles exceed four knot items");
    assert!(matches!(error, CodecError::ResourceLimit(resource)
        if resource.dimension == ResourceDimension::CollectionItems
            && resource.operation == "sketch geometry copy"));
    assert_eq!(
        copy_with_policy(&geometry, &DecodePolicy::service()).expect("service copy"),
        geometry
    );
}

#[test]
fn sketch_native_copy_refuses_retained_text() {
    let geometry = SketchGeometry::native(NonBlankString::new("native").expect("nonblank"));
    let mut policy = DecodePolicy::service();
    policy.limits.max_retained_bytes = 5;
    let error = copy_with_policy(&geometry, &policy).expect_err("six bytes exceed five");
    assert!(matches!(error, CodecError::ResourceLimit(resource)
        if resource.dimension == ResourceDimension::RetainedBytes
            && resource.operation == "sketch geometry copy"));
    assert_eq!(
        copy_with_policy(&geometry, &DecodePolicy::service()).expect("service copy"),
        geometry
    );
}

#[test]
fn sketch_external_copy_refuses_nested_text_and_subelements() {
    let geometry =
        SketchGeometry::from_admitted_definition(SketchGeometryDefinition::ExternalReference {
            document: Some("doc".to_owned()),
            object: NonBlankString::new("object").expect("nonblank"),
            subelements: vec!["edge".to_owned()],
        });
    let mut policy = DecodePolicy::service();
    policy.limits.max_retained_bytes = 2;
    let error = copy_with_policy(&geometry, &policy).expect_err("document exceeds retained cap");
    assert!(matches!(error, CodecError::ResourceLimit(resource)
        if resource.dimension == ResourceDimension::RetainedBytes
            && resource.operation == "sketch geometry copy"));
    policy.limits.max_retained_bytes = DecodePolicy::service().limits.max_retained_bytes;
    policy.limits.max_collection_items = 0;
    let error =
        copy_with_policy(&geometry, &policy).expect_err("subelement exceeds collection cap");
    assert!(matches!(error, CodecError::ResourceLimit(resource)
        if resource.dimension == ResourceDimension::CollectionItems
            && resource.operation == "sketch geometry copy"));
    assert_eq!(
        copy_with_policy(&geometry, &DecodePolicy::service()).expect("service copy"),
        geometry
    );
}