Kyle Bayes
eabd4c06f9
PiperOrigin-RevId: 606280564 Change-Id: I9fec9eb3538f63f84e1982f21e1a93f16342d540
136 lines
3.9 KiB
C++
136 lines
3.9 KiB
C++
// Copyright 2024 DeepMind Technologies Limited
|
|
//
|
|
// 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.
|
|
|
|
#include <optional>
|
|
#include <string>
|
|
|
|
#include <gtest/gtest.h>
|
|
#include "src/xml/xml_native_reader.h"
|
|
#include "src/xml/xml_util.h"
|
|
#include "test/fixture.h"
|
|
#include <absl/strings/numbers.h>
|
|
#include <absl/strings/str_format.h>
|
|
|
|
namespace mujoco {
|
|
namespace {
|
|
|
|
|
|
using XMLSchemaTest = MujocoTest;
|
|
|
|
static std::optional<std::string> IsValidSchemaFormat(
|
|
const char* schema[][mjXATTRNUM], unsigned nrow) {
|
|
if (schema[0][0][0] == '<' || schema[0][0][0] == '>') {
|
|
return "expected element, found bracket";
|
|
}
|
|
|
|
// check entire schema for null pointers
|
|
for (int i = 0; i < nrow; i++) {
|
|
// base pointers
|
|
if (!schema[i][0]) {
|
|
return "null pointer found in row " + std::to_string(i);
|
|
}
|
|
|
|
// detect element
|
|
if (schema[i][0][0] != '<' && schema[i][0][0] != '>') {
|
|
// first 3 pointers required
|
|
if (!schema[i][1] || !schema[i][2]) {
|
|
return absl::StrFormat("expected element, found null pointers"
|
|
"in row %d, element %s", i, schema[i][0]);
|
|
}
|
|
|
|
// check type
|
|
if (schema[i][1][0] != '!' && schema[i][1][0] != '?' &&
|
|
schema[i][1][0] != '*' && schema[i][1][0] != 'R') {
|
|
return absl::StrFormat("invalid type in row %d, element %s",
|
|
i, schema[i][0]);
|
|
}
|
|
|
|
// number of attributes
|
|
int nattr = 0;
|
|
if (!absl::SimpleAtoi(schema[i][2], &nattr)) {
|
|
return absl::StrFormat("unparseable number of attributes in"
|
|
" row %d, element %s", i, schema[i][0]);
|
|
} else if (nattr < 0 || nattr > mjXATTRNUM - 3) {
|
|
return absl::StrFormat("invalid number of attributes in"
|
|
" row %d, element %s", i, schema[i][0]);
|
|
}
|
|
|
|
// attribute pointers
|
|
for (int j = 0; j < nattr; j++) {
|
|
if (!schema[i][3 + j]) {
|
|
return absl::StrFormat("null attribute %d in"
|
|
" row %d, element %s", j, i, schema[i][0]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// process sub-elements of complex element
|
|
if (nrow > 1) {
|
|
// check for bracketed block
|
|
if (schema[1][0][0] != '<' || schema[nrow - 1][0][0] != '>') {
|
|
return "expected brackets after complex element";
|
|
}
|
|
|
|
// parse block into simple and complex elements
|
|
int start = 2;
|
|
while (start < nrow - 1) {
|
|
int end = start;
|
|
|
|
// look for bracketed block at start + 1
|
|
if (schema[start + 1][0][0] == '<') {
|
|
// look for corresponding closing bracket
|
|
int cnt = 0;
|
|
while (end <= nrow - 1) {
|
|
if (schema[end][0][0] == '<') {
|
|
cnt++;
|
|
} else if (schema[end][0][0] == '>') {
|
|
cnt--;
|
|
if (cnt == 0) {
|
|
break;
|
|
}
|
|
}
|
|
end++;
|
|
}
|
|
|
|
// closing bracket not found
|
|
if (end > nrow - 1) {
|
|
return "matching closing bracket not found";
|
|
}
|
|
}
|
|
|
|
// recursively check for error
|
|
auto error = IsValidSchemaFormat(schema + start, end - start + 1);
|
|
if (error.has_value()) {
|
|
return error;
|
|
}
|
|
|
|
// proceed with next subelement
|
|
start = end + 1;
|
|
}
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
TEST_F(XMLSchemaTest, MjcfSchemaTest) {
|
|
auto error = IsValidSchemaFormat(MJCF, nMJCF);
|
|
auto error_msg = error.value_or("");
|
|
|
|
EXPECT_EQ(error_msg, "");
|
|
ASSERT_FALSE(error.has_value());
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace mujoco
|