starboard/shared/starboard/media/mime_type_test.cc

// Copyright 2016 The Cobalt Authors. All Rights Reserved.
//
// 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 "starboard/shared/starboard/media/mime_type.h"

#include "testing/gtest/include/gtest/gtest.h"

namespace starboard {
namespace shared {
namespace starboard {
namespace media {
namespace {

TEST(MimeTypeTest, EmptyString) {
  MimeType mime_type("");
  EXPECT_FALSE(mime_type.is_valid());
}

// Valid mime type must have a type/subtype without space in between.
TEST(MimeTypeTest, InvalidMimeType) {
  {
    MimeType mime_type("video");
    EXPECT_FALSE(mime_type.is_valid());
  }

  {
    MimeType mime_type("video/");
    EXPECT_FALSE(mime_type.is_valid());
  }

  {
    MimeType mime_type("/mp4");
    EXPECT_FALSE(mime_type.is_valid());
  }

  {
    MimeType mime_type("video /mp4");
    EXPECT_FALSE(mime_type.is_valid());
  }

  {
    MimeType mime_type("video/ mp4");
    EXPECT_FALSE(mime_type.is_valid());
  }

  {
    MimeType mime_type("video / mp4");
    EXPECT_FALSE(mime_type.is_valid());
  }

  {  // "codecs" parameter isn't the first parameter.
    MimeType mime_type("audio/mp4;param1=\" value1 \";codecs=\"abc, def\"");
    EXPECT_FALSE(mime_type.is_valid());
  }

  {  // More than one "codecs" parameters.
    MimeType mime_type(
        "audio/mp4;codecs=\"abc, def\";"
        "param1=\" value1 \";codecs=\"abc, def\"");
    EXPECT_FALSE(mime_type.is_valid());
  }
  {
    // Parameter name must not be empty.
    MimeType mime_type("video/mp4; =value");
    EXPECT_FALSE(mime_type.is_valid());
  }
  {
    // Parameter value must not be empty.
    MimeType mime_type("video/mp4; name=");
    EXPECT_FALSE(mime_type.is_valid());
  }
  {
    // No '|' allowed.
    MimeType mime_type("video/mp4; name=ab|c");
    EXPECT_FALSE(mime_type.is_valid());
  }
}

TEST(MimeTypeTest, ValidContentTypeWithTypeAndSubtypeOnly) {
  {
    MimeType mime_type("video/mp4");
    EXPECT_TRUE(mime_type.is_valid());
    EXPECT_EQ("video", mime_type.type());
    EXPECT_EQ("mp4", mime_type.subtype());
  }

  {
    MimeType mime_type("audio/mp4");
    EXPECT_TRUE(mime_type.is_valid());
  }

  {
    MimeType mime_type("abc/xyz");
    EXPECT_TRUE(mime_type.is_valid());
  }
}

TEST(MimeTypeTest, TypeNotAtBeginning) {
  MimeType mime_type("codecs=\"abc\"; audio/mp4");
  EXPECT_FALSE(mime_type.is_valid());
}

TEST(MimeTypeTest, ValidContentTypeWithParams) {
  {
    MimeType mime_type("video/mp4; name=123");
    EXPECT_TRUE(mime_type.is_valid());
  }

  {
    MimeType mime_type("audio/mp4;codecs=\"abc\"");
    EXPECT_TRUE(mime_type.is_valid());
  }

  {
    MimeType mime_type("  audio/mp4  ;  codecs   =  \"abc\"  ");
    EXPECT_TRUE(mime_type.is_valid());
  }
}

TEST(MimeTypeTest, GetCodecs) {
  {
    MimeType mime_type("audio/mp4;codecs=\"abc\"");
    EXPECT_EQ(1, mime_type.GetCodecs().size());
    EXPECT_EQ("abc", mime_type.GetCodecs()[0]);
  }

  {
    MimeType mime_type("audio/mp4;codecs=\"abc, def\"");
    EXPECT_EQ(2, mime_type.GetCodecs().size());
    EXPECT_EQ("abc", mime_type.GetCodecs()[0]);
    EXPECT_EQ("def", mime_type.GetCodecs()[1]);
  }

  {
    MimeType mime_type("audio/mp4;codecs=\"abc, def\";param1=\" value1 \"");
    EXPECT_EQ(2, mime_type.GetCodecs().size());
  }
}

TEST(MimeTypeTest, ParamCount) {
  {
    MimeType mime_type("video/mp4");
    EXPECT_EQ(0, mime_type.GetParamCount());
  }

  {
    MimeType mime_type("video/mp4; width=1920");
    EXPECT_EQ(1, mime_type.GetParamCount());
  }

  {
    MimeType mime_type("video/mp4; width=1920; height=1080");
    EXPECT_EQ(2, mime_type.GetParamCount());
  }
}

TEST(MimeTypeTest, GetParamType) {
  {
    MimeType mime_type(
        "video/mp4; name0=123; name1=1.2; name2=xyz; name3=true; name4=false");
    EXPECT_EQ(MimeType::kParamTypeInteger, mime_type.GetParamType(0));
    EXPECT_EQ(MimeType::kParamTypeFloat, mime_type.GetParamType(1));
    EXPECT_EQ(MimeType::kParamTypeString, mime_type.GetParamType(2));
    EXPECT_EQ(MimeType::kParamTypeBoolean, mime_type.GetParamType(3));
    EXPECT_EQ(MimeType::kParamTypeBoolean, mime_type.GetParamType(4));
  }

  {
    MimeType mime_type("video/mp4; name0=\"123\"; name1=\"abc\"");
    EXPECT_EQ(MimeType::kParamTypeString, mime_type.GetParamType(0));
    EXPECT_EQ(MimeType::kParamTypeString, mime_type.GetParamType(1));
  }

  {
    MimeType mime_type("video/mp4; name1=\" abc \"");
    EXPECT_EQ(MimeType::kParamTypeString, mime_type.GetParamType(0));
  }
}

TEST(MimeTypeTest, GetParamName) {
  {
    MimeType mime_type("video/mp4; name0=123; name1=1.2; name2=xyz");
    EXPECT_EQ("name0", mime_type.GetParamName(0));
    EXPECT_EQ("name1", mime_type.GetParamName(1));
    EXPECT_EQ("name2", mime_type.GetParamName(2));
  }
}

TEST(MimeTypeTest, GetParamIntValueWithIndex) {
  {
    MimeType mime_type("video/mp4; name=123");
    EXPECT_EQ(123, mime_type.GetParamIntValue(0));
  }

  {
    MimeType mime_type("video/mp4; width=1920; height=1080");
    EXPECT_EQ(1920, mime_type.GetParamIntValue(0));
    EXPECT_EQ(1080, mime_type.GetParamIntValue(1));
  }

  {
    MimeType mime_type("audio/mp4; channels=6");
    EXPECT_EQ(6, mime_type.GetParamIntValue(0));
  }
}

TEST(MimeTypeTest, GetParamFloatValueWithIndex) {
  MimeType mime_type("video/mp4; name0=123; name1=123.4");
  EXPECT_FLOAT_EQ(123.f, mime_type.GetParamFloatValue(0));
  EXPECT_FLOAT_EQ(123.4f, mime_type.GetParamFloatValue(1));
}

TEST(MimeTypeTest, GetParamStringValueWithIndex) {
  {
    MimeType mime_type("video/mp4; name0=123; name1=abc; name2=\"xyz\"");
    EXPECT_EQ("123", mime_type.GetParamStringValue(0));
    EXPECT_EQ("abc", mime_type.GetParamStringValue(1));
    EXPECT_EQ("xyz", mime_type.GetParamStringValue(2));
  }

  {
    MimeType mime_type("video/mp4; name=\" xyz  \"");
    EXPECT_EQ(" xyz  ", mime_type.GetParamStringValue(0));
  }
}

TEST(MimeTypeTest, GetParamBoolValueWithIndex) {
  MimeType mime_type("video/mp4; name0=true; name1=false");
  EXPECT_TRUE(mime_type.GetParamBoolValue(0));
  EXPECT_FALSE(mime_type.GetParamBoolValue(1));
}

TEST(MimeTypeTest, GetParamValueInInvalidType) {
  MimeType mime_type("video/mp4; name0=abc; name1=123.4");
  EXPECT_FLOAT_EQ(0, mime_type.GetParamIntValue(0));
  EXPECT_FLOAT_EQ(0.f, mime_type.GetParamFloatValue(0));
  EXPECT_FLOAT_EQ(0, mime_type.GetParamIntValue(1));
}

TEST(MimeTypeTest, GetParamIntValueWithName) {
  {
    MimeType mime_type("video/mp4; name=123");
    EXPECT_EQ(123, mime_type.GetParamIntValue("name", 0));
    EXPECT_EQ(6, mime_type.GetParamIntValue("channels", 6));
  }

  {
    MimeType mime_type("video/mp4; width=1920; height=1080");
    EXPECT_EQ(1920, mime_type.GetParamIntValue("width", 0));
    EXPECT_EQ(1080, mime_type.GetParamIntValue("height", 0));
  }

  {
    MimeType mime_type("audio/mp4; channels=6");
    EXPECT_EQ(6, mime_type.GetParamIntValue("channels", 0));
  }
}

TEST(MimeTypeTest, GetParamFloatValueWithName) {
  {
    MimeType mime_type("video/mp4; name0=123; name1=123.4");
    EXPECT_FLOAT_EQ(123.f, mime_type.GetParamFloatValue("name0", 0.f));
    EXPECT_FLOAT_EQ(123.4f, mime_type.GetParamFloatValue("name1", 0.f));
    EXPECT_FLOAT_EQ(59.96f, mime_type.GetParamFloatValue("framerate", 59.96f));
  }
}

TEST(MimeTypeTest, GetParamStringValueWithName) {
  {
    MimeType mime_type("video/mp4; name0=123; name1=abc; name2=\"xyz\"");
    EXPECT_EQ("123", mime_type.GetParamStringValue("name0", ""));
    EXPECT_EQ("abc", mime_type.GetParamStringValue("name1", ""));
    EXPECT_EQ("xyz", mime_type.GetParamStringValue("name2", ""));
    EXPECT_EQ("h263", mime_type.GetParamStringValue("codecs", "h263"));
  }

  {
    MimeType mime_type("video/mp4; name=\" xyz  \"");
    EXPECT_EQ(" xyz  ", mime_type.GetParamStringValue("name", ""));
  }
}

TEST(MimeTypeTest, GetParamBooleanValueWithName) {
  MimeType mime_type("video/mp4; name0=true; name1=false; name2=trues");
  EXPECT_TRUE(mime_type.GetParamBoolValue("name0", false));
  EXPECT_FALSE(mime_type.GetParamBoolValue("name1", true));
  // Default value
  EXPECT_FALSE(mime_type.GetParamBoolValue("name2", false));
}

TEST(MimeTypeTest, ReadParamOfDifferentTypes) {
  // Ensure that the parameter type is enforced correctly.
  MimeType mime_type("video/mp4; string=value; int=1; float=1.0; bool=true");
  ASSERT_TRUE(mime_type.is_valid());
  // Read params as their original types.
  EXPECT_EQ(mime_type.GetParamStringValue("string", ""), "value");
  EXPECT_EQ(mime_type.GetParamIntValue("int", 0), 1);
  EXPECT_EQ(mime_type.GetParamFloatValue("float", 0.0), 1.0);
  EXPECT_EQ(mime_type.GetParamBoolValue("bool", false), true);
  // All param types can be read as strings.
  EXPECT_EQ(mime_type.GetParamStringValue("int", ""), "1");
  EXPECT_EQ(mime_type.GetParamStringValue("float", ""), "1.0");
  EXPECT_EQ(mime_type.GetParamStringValue("bool", ""), "true");
  // Int can also be read as float.
  EXPECT_EQ(mime_type.GetParamFloatValue("int", 0.0), 1.0);

  // Test failing validation for ints,
  EXPECT_EQ(mime_type.GetParamIntValue("string", 0), 0);
  EXPECT_EQ(mime_type.GetParamIntValue("float", 0), 0);
  EXPECT_EQ(mime_type.GetParamIntValue("bool", 0), 0);

  // floats,
  EXPECT_EQ(mime_type.GetParamFloatValue("string", 0.0), 0.0);
  EXPECT_EQ(mime_type.GetParamFloatValue("bool", 0.0), 0.0);

  // and bools.
  EXPECT_FALSE(mime_type.GetParamBoolValue("string", false));
  EXPECT_FALSE(mime_type.GetParamBoolValue("int", false));
  EXPECT_FALSE(mime_type.GetParamBoolValue("float", false));
}

TEST(MimeTypeTest, ParseInvalidParamString) {
  EXPECT_FALSE(MimeType::ParseParamString("", nullptr));
  EXPECT_FALSE(MimeType::ParseParamString("invalid", nullptr));
  EXPECT_FALSE(MimeType::ParseParamString("val=0;", nullptr));
  EXPECT_FALSE(MimeType::ParseParamString("val=a|b", nullptr));
  EXPECT_FALSE(MimeType::ParseParamString("val=", nullptr));
}

TEST(MimeTypeTest, ParseValidParamString) {
  MimeType::Param result;

  EXPECT_TRUE(MimeType::ParseParamString("val=0", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeInteger);
  EXPECT_EQ(result.int_value, 0);

  EXPECT_TRUE(MimeType::ParseParamString("val=1", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeInteger);
  EXPECT_EQ(result.int_value, 1);

  EXPECT_TRUE(MimeType::ParseParamString("val=-1", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeInteger);
  EXPECT_EQ(result.int_value, -1);

  EXPECT_TRUE(MimeType::ParseParamString("val=0.0", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeFloat);
  EXPECT_EQ(result.float_value, 0.0f);

  EXPECT_TRUE(MimeType::ParseParamString("val=1.0", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeFloat);
  EXPECT_EQ(result.float_value, 1.0f);

  EXPECT_TRUE(MimeType::ParseParamString("val=-1.0", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeFloat);
  EXPECT_EQ(result.float_value, -1.0f);

  EXPECT_TRUE(MimeType::ParseParamString("val=true", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeBoolean);
  EXPECT_EQ(result.bool_value, true);

  EXPECT_TRUE(MimeType::ParseParamString("val=false", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeBoolean);
  EXPECT_EQ(result.bool_value, false);

  EXPECT_TRUE(MimeType::ParseParamString("val=\"\"", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeString);
  EXPECT_EQ(result.string_value, "");

  EXPECT_TRUE(MimeType::ParseParamString("val=\"abc\"", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeString);
  EXPECT_EQ(result.string_value, "abc");

  EXPECT_TRUE(MimeType::ParseParamString("val=abc", &result));
  EXPECT_EQ(result.name, "val");
  EXPECT_EQ(result.type, MimeType::kParamTypeString);
  EXPECT_EQ(result.string_value, "abc");
}

TEST(MimeTypeTest, ValidateParamsWithPatterns) {
  MimeType mime_type("video/mp4; string=yes");
  EXPECT_TRUE(mime_type.ValidateStringParameter("string", "yes"));
  EXPECT_TRUE(mime_type.ValidateStringParameter("string", "yes|no"));
  EXPECT_TRUE(mime_type.ValidateStringParameter("string", "no|yes|no"));
  EXPECT_TRUE(mime_type.ValidateStringParameter("string", "no|no|yes"));
  EXPECT_TRUE(mime_type.ValidateStringParameter("string", "noyes|yes"));
  EXPECT_FALSE(mime_type.ValidateStringParameter("string", "no"));
}

TEST(MimeTypeTest, ValidateParamsWithShortPatterns) {
  MimeType mime_type("video/mp4; string=y");
  EXPECT_TRUE(mime_type.ValidateStringParameter("string", "y"));
  EXPECT_TRUE(mime_type.ValidateStringParameter("string", "y|n"));
  EXPECT_TRUE(mime_type.ValidateStringParameter("string", "n|y"));
  EXPECT_FALSE(mime_type.ValidateStringParameter("string", "n"));
}

TEST(MimeTypeTest, ValidateParamsWithPartialMatches) {
  MimeType mime_type("video/mp4; string=yes");
  EXPECT_FALSE(mime_type.ValidateStringParameter("string", "yesno|no"));
  EXPECT_FALSE(mime_type.ValidateStringParameter("string", "noyes|no"));
  EXPECT_FALSE(mime_type.ValidateStringParameter("string", "no|yesno"));
  EXPECT_FALSE(mime_type.ValidateStringParameter("string", "no|noyes"));
}

TEST(MimeTypeTest, ValidateMissingParam) {
  MimeType mime_type("video/mp4");
  EXPECT_TRUE(mime_type.ValidateStringParameter("string"));
  EXPECT_EQ(mime_type.GetParamStringValue("string", "default"), "default");
}

TEST(MimeTypeTest, ValidateParamsWithEmptyishPattern) {
  MimeType mime_type("video/mp4; string=yes");
  EXPECT_TRUE(mime_type.ValidateStringParameter("string", ""));
  EXPECT_FALSE(mime_type.ValidateStringParameter("string", "|"));
  EXPECT_FALSE(mime_type.ValidateStringParameter("string", "||"));
}

TEST(MimeTypeTest, ValidateParamWithInvalidMimeType) {
  MimeType mime_type("video/mp4; string=");
  ASSERT_FALSE(mime_type.is_valid());
  EXPECT_FALSE(mime_type.ValidateStringParameter("string"));
}

}  // namespace
}  // namespace media
}  // namespace starboard
}  // namespace shared
}  // namespace starboard