// Copyright 2006 The Closure Library 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.

goog.provide('goog.formatTest');
goog.setTestOnly('goog.formatTest');

goog.require('goog.dom');
goog.require('goog.dom.TagName');
goog.require('goog.format');
goog.require('goog.string');
goog.require('goog.testing.PropertyReplacer');
goog.require('goog.testing.jsunit');

var propertyReplacer = new goog.testing.PropertyReplacer();

function tearDown() {
  // set wordBreakHtml back to the original value (some tests edit this member).
  propertyReplacer.reset();
}

function testFormatFileSize() {
  var fileSize = goog.format.fileSize;

  assertEquals('45', fileSize(45));
  assertEquals('45', fileSize(45, 0));
  assertEquals('45', fileSize(45, 1));
  assertEquals('45', fileSize(45, 3));
  assertEquals('454', fileSize(454));
  assertEquals('600', fileSize(600));

  assertEquals('1K', fileSize(1024));
  assertEquals('2K', fileSize(2 * 1024));
  assertEquals('5K', fileSize(5 * 1024));
  assertEquals('5.123K', fileSize(5.12345 * 1024, 3));
  assertEquals('5.68K', fileSize(5.678 * 1024, 2));

  assertEquals('1M', fileSize(1024 * 1024));
  assertEquals('1.5M', fileSize(1.5 * 1024 * 1024));
  assertEquals('2M', fileSize(1.5 * 1024 * 1024, 0));
  assertEquals('1.5M', fileSize(1.51 * 1024 * 1024, 1));
  assertEquals('1.56M', fileSize(1.56 * 1024 * 1024, 2));

  assertEquals('1G', fileSize(1024 * 1024 * 1024));
  assertEquals('6G', fileSize(6 * 1024 * 1024 * 1024));
  assertEquals('12.06T', fileSize(12345.6789 * 1024 * 1024 * 1024));
}

function testIsConvertableScaledNumber() {
  var isConvertableScaledNumber = goog.format.isConvertableScaledNumber;

  assertTrue(isConvertableScaledNumber('0'));
  assertTrue(isConvertableScaledNumber('45'));
  assertTrue(isConvertableScaledNumber('45K'));
  assertTrue(isConvertableScaledNumber('45MB'));
  assertTrue(isConvertableScaledNumber('45GB'));
  assertTrue(isConvertableScaledNumber('45T'));
  assertTrue(isConvertableScaledNumber('2.33P'));
  assertTrue(isConvertableScaledNumber('3.45E'));
  assertTrue(isConvertableScaledNumber('5.33Z'));
  assertTrue(isConvertableScaledNumber('7.22Y'));
  assertTrue(isConvertableScaledNumber('45m'));
  assertTrue(isConvertableScaledNumber('45u'));
  assertTrue(isConvertableScaledNumber('-5.0n'));

  assertFalse(isConvertableScaledNumber('45x'));
  assertFalse(isConvertableScaledNumber('ux'));
  assertFalse(isConvertableScaledNumber('K'));
}

function testNumericValueToString() {
  var numericValueToString = goog.format.numericValueToString;

  assertEquals('0', numericValueToString(0.0));
  assertEquals('45', numericValueToString(45));
  assertEquals('454', numericValueToString(454));
  assertEquals('600', numericValueToString(600));

  assertEquals('1.02K', numericValueToString(1024));
  assertEquals('2.05K', numericValueToString(2 * 1024));
  assertEquals('5.12K', numericValueToString(5 * 1024));
  assertEquals('5.246K', numericValueToString(5.12345 * 1024, 3));
  assertEquals('5.81K', numericValueToString(5.678 * 1024, 2));

  assertEquals('1.05M', numericValueToString(1024 * 1024));
  assertEquals('1.57M', numericValueToString(1.5 * 1024 * 1024));
  assertEquals('2M', numericValueToString(1.5 * 1024 * 1024, 0));
  assertEquals('1.6M', numericValueToString(1.51 * 1024 * 1024, 1));
  assertEquals('1.64M', numericValueToString(1.56 * 1024 * 1024, 2));

  assertEquals('1.07G', numericValueToString(1024 * 1024 * 1024));
  assertEquals('6.44G', numericValueToString(6 * 1024 * 1024 * 1024));
  assertEquals('13.26T', numericValueToString(12345.6789 * 1024 * 1024 * 1024));
  assertEquals('50.67P', numericValueToString(45 * Math.pow(1024, 5)));
  assertEquals('57.65E', numericValueToString(50 * Math.pow(1024, 6)));
  assertEquals('77.33Z', numericValueToString(65.5 * Math.pow(1024, 7)));
  assertEquals('97.56Y', numericValueToString(80.7 * Math.pow(1024, 8)));

  assertEquals('23.4m', numericValueToString(0.0234));
  assertEquals('1.23u', numericValueToString(0.00000123));
  assertEquals('15.78n', numericValueToString(0.000000015784));
  assertEquals('0.58u', numericValueToString(0.0000005784));
  assertEquals('0.5', numericValueToString(0.5));

  assertEquals('-45', numericValueToString(-45.3, 0));
  assertEquals('-45', numericValueToString(-45.5, 0));
  assertEquals('-46', numericValueToString(-45.51, 0));
}

function testFormatNumBytes() {
  var numBytesToString = goog.format.numBytesToString;

  assertEquals('45', numBytesToString(45));
  assertEquals('454', numBytesToString(454));

  assertEquals('5KB', numBytesToString(5 * 1024));
  assertEquals('1MB', numBytesToString(1024 * 1024));
  assertEquals('6GB', numBytesToString(6 * 1024 * 1024 * 1024));
  assertEquals('12.06TB', numBytesToString(12345.6789 * 1024 * 1024 * 1024));
  assertEquals('45PB', numBytesToString(45 * Math.pow(1024, 5)));
  assertEquals('50EB', numBytesToString(50 * Math.pow(1024, 6)));
  assertEquals('65.5ZB', numBytesToString(65.5 * Math.pow(1024, 7)));
  assertEquals('80.7YB', numBytesToString(80.7 * Math.pow(1024, 8)));

  assertEquals('454', numBytesToString(454, 2, true, true));
  assertEquals('5 KB', numBytesToString(5 * 1024, 2, true, true));
}

function testStringToNumeric() {
  var stringToNumericValue = goog.format.stringToNumericValue;
  var epsilon = Math.pow(10, -10);

  assertNaN(stringToNumericValue('foo'));

  assertEquals(45, stringToNumericValue('45'));
  assertEquals(-45, stringToNumericValue('-45'));
  assertEquals(-45, stringToNumericValue('-45'));
  assertEquals(454, stringToNumericValue('454'));

  assertEquals(5 * 1024, stringToNumericValue('5KB'));
  assertEquals(1024 * 1024, stringToNumericValue('1MB'));
  assertEquals(6 * 1024 * 1024 * 1024, stringToNumericValue('6GB'));
  assertEquals(13260110230978.56, stringToNumericValue('12.06TB'));

  assertEquals(5010, stringToNumericValue('5.01K'));
  assertEquals(5100000, stringToNumericValue('5.1M'));
  assertTrue(Math.abs(0.051 - stringToNumericValue('51.0m')) < epsilon);
  assertTrue(Math.abs(0.000051 - stringToNumericValue('51.0u')) < epsilon);
}

function testStringToNumBytes() {
  var stringToNumBytes = goog.format.stringToNumBytes;
  var epsilon = 0.1;

  assertEquals(45, stringToNumBytes('45'));
  assertEquals(454, stringToNumBytes('454'));

  assertEquals(5 * 1024, stringToNumBytes('5K'));
  assertEquals(1024 * 1024, stringToNumBytes('1M'));
  assertEquals(6 * 1024 * 1024 * 1024, stringToNumBytes('6G'));
  assertEquals(13260110230978.56, stringToNumBytes('12.06T'));
  assertTrue(
      Math.abs(3.191564163782621e+24 - stringToNumBytes('2.64Y')) < epsilon);
}

function testInsertWordBreaks() {
  // HTML that gets inserted is browser dependent, ensure for the test it is
  // a constant - browser dependent HTML is for display purposes only.
  propertyReplacer.set(goog.format, 'WORD_BREAK_HTML', '<wbr>');

  var insertWordBreaks = goog.format.insertWordBreaks;

  assertEquals('abcdef', insertWordBreaks('abcdef', 10));
  assertEquals('ab<wbr>cd<wbr>ef', insertWordBreaks('abcdef', 2));
  assertEquals(
      'a<wbr>b<wbr>c<wbr>d<wbr>e<wbr>f', insertWordBreaks('abcdef', 1));

  assertEquals(
      'a&amp;b=<wbr>=fal<wbr>se', insertWordBreaks('a&amp;b==false', 4));
  assertEquals(
      '&lt;&amp;&gt;&raquo;<wbr>&laquo;',
      insertWordBreaks('&lt;&amp;&gt;&raquo;&laquo;', 4));

  assertEquals('a<wbr>b<wbr>c d<wbr>e<wbr>f', insertWordBreaks('abc def', 1));
  assertEquals('ab<wbr>c de<wbr>f', insertWordBreaks('abc def', 2));
  assertEquals('abc def', insertWordBreaks('abc def', 3));
  assertEquals('abc def', insertWordBreaks('abc def', 4));

  assertEquals('a<b>cd</b>e<wbr>f', insertWordBreaks('a<b>cd</b>ef', 4));
  assertEquals(
      'Thi<wbr>s is a <a href="">lin<wbr>k</a>.',
      insertWordBreaks('This is a <a href="">link</a>.', 3));
  assertEquals(
      '<abc a="&amp;&amp;&amp;&amp;&amp;">a<wbr>b',
      insertWordBreaks('<abc a="&amp;&amp;&amp;&amp;&amp;">ab', 1));

  assertEquals('ab\u0300<wbr>cd', insertWordBreaks('ab\u0300cd', 2));
  assertEquals('ab\u036F<wbr>cd', insertWordBreaks('ab\u036Fcd', 2));
  assertEquals('ab<wbr>\u0370c<wbr>d', insertWordBreaks('ab\u0370cd', 2));
  assertEquals('ab<wbr>\uFE1Fc<wbr>d', insertWordBreaks('ab\uFE1Fcd', 2));
  assertEquals(
      'ab\u0300<wbr>c\u0301<wbr>de<wbr>f',
      insertWordBreaks('ab\u0300c\u0301def', 2));
}

function testInsertWordBreaksWithFormattingCharacters() {
  // HTML that gets inserted is browser dependent, ensure for the test it is
  // a constant - browser dependent HTML is for display purposes only.
  propertyReplacer.set(goog.format, 'WORD_BREAK_HTML', '<wbr>');
  var insertWordBreaks = goog.format.insertWordBreaks;

  // A date in Arabic-Indic digits with Right-to-Left Marks (U+200F).
  // The date is "11<RLM>/01<RLM>/2012".
  var textWithRLMs = 'This is a date - ' +
      '\u0661\u0661\u200f/\u0660\u0661\u200f/\u0662\u0660\u0661\u0662';
  // A string of 10 Xs with invisible formatting characters in between.
  // These characters are in the ranges U+200C to U+200F and U+202A to
  // U+202E, inclusive. See: http://unicode.org/charts/PDF/U2000.pdf
  var stringWithInvisibleFormatting = 'X\u200cX\u200dX\u200eX\u200fX\u202a' +
      'X\u202bX\u202cX\u202dX\u202eX';
  // A string formed by concatenating copies of the previous string alternating
  // with characters which behave like breaking spaces. Besides the space
  // character itself, the other characters are in the range U+2000 to U+200B
  // inclusive, except for the exclusion of U+2007 and inclusion of U+2029.
  // See: http://unicode.org/charts/PDF/U2000.pdf
  var stringWithInvisibleFormattingAndSpacelikeCharacters =
      stringWithInvisibleFormatting + ' ' + stringWithInvisibleFormatting +
      '\u2000' + stringWithInvisibleFormatting + '\u2001' +
      stringWithInvisibleFormatting + '\u2002' + stringWithInvisibleFormatting +
      '\u2003' + stringWithInvisibleFormatting + '\u2005' +
      stringWithInvisibleFormatting + '\u2006' + stringWithInvisibleFormatting +
      '\u2008' + stringWithInvisibleFormatting + '\u2009' +
      stringWithInvisibleFormatting + '\u200A' + stringWithInvisibleFormatting +
      '\u200B' + stringWithInvisibleFormatting + '\u2029' +
      stringWithInvisibleFormatting;

  // Test that the word break algorithm does not count RLMs towards word
  // length, and therefore does not insert word breaks into a typical date
  // written in Arabic-Indic digits with RTMs (b/5853915).
  assertEquals(textWithRLMs, insertWordBreaks(textWithRLMs, 10));

  // Test that invisible formatting characters are not counted towards word
  // length, and that characters which are treated as breaking spaces behave as
  // breaking spaces.
  assertEquals(
      stringWithInvisibleFormattingAndSpacelikeCharacters,
      insertWordBreaks(
          stringWithInvisibleFormattingAndSpacelikeCharacters, 10));
}

function testInsertWordBreaksBasic() {
  // HTML that gets inserted is browser dependent, ensure for the test it is
  // a constant - browser dependent HTML is for display purposes only.
  propertyReplacer.set(goog.format, 'WORD_BREAK_HTML', '<wbr>');
  var insertWordBreaksBasic = goog.format.insertWordBreaksBasic;

  assertEquals('abcdef', insertWordBreaksBasic('abcdef', 10));
  assertEquals('ab<wbr>cd<wbr>ef', insertWordBreaksBasic('abcdef', 2));
  assertEquals(
      'a<wbr>b<wbr>c<wbr>d<wbr>e<wbr>f', insertWordBreaksBasic('abcdef', 1));
  assertEquals(
      'ab\u0300<wbr>c\u0301<wbr>de<wbr>f',
      insertWordBreaksBasic('ab\u0300c\u0301def', 2));

  assertEquals(
      'Inserting word breaks into the word "Russia" should work fine.',
      '\u0420\u043E<wbr>\u0441\u0441<wbr>\u0438\u044F',
      insertWordBreaksBasic('\u0420\u043E\u0441\u0441\u0438\u044F', 2));

  // The word 'Internet' in Hindi.
  var hindiInternet = '\u0907\u0902\u091F\u0930\u0928\u0947\u091F';
  assertEquals(
      'The basic algorithm is not good enough to insert word ' +
          'breaks into Hindi.',
      hindiInternet, insertWordBreaksBasic(hindiInternet, 2));
  // The word 'Internet' in Hindi broken into slashes.
  assertEquals(
      'Hindi can have word breaks inserted between slashes',
      hindiInternet + '<wbr>/' + hindiInternet + '<wbr>.' + hindiInternet,
      insertWordBreaksBasic(
          hindiInternet + '/' + hindiInternet + '.' + hindiInternet, 2));
}

function testWordBreaksWorking() {
  var text = goog.string.repeat('test', 20);
  var textWbr = goog.string.repeat('test' + goog.format.WORD_BREAK_HTML, 20);

  var overflowEl = goog.dom.createDom(
      goog.dom.TagName.DIV,
      {'style': 'width: 100px; overflow: hidden; margin 5px'});
  var wbrEl = goog.dom.createDom(
      goog.dom.TagName.DIV,
      {'style': 'width: 100px; overflow: hidden; margin-top: 15px'});
  goog.dom.appendChild(goog.global.document.body, overflowEl);
  goog.dom.appendChild(goog.global.document.body, wbrEl);

  overflowEl.innerHTML = text;
  wbrEl.innerHTML = textWbr;

  assertTrue('Text should overflow', overflowEl.scrollWidth > 100);
  assertTrue('Text should not overflow', wbrEl.scrollWidth <= 100);
}

function testWordBreaksRemovedFromTextContent() {
  var expectedText = goog.string.repeat('test', 20);
  var textWbr = goog.string.repeat('test' + goog.format.WORD_BREAK_HTML, 20);

  var wbrEl = goog.dom.createDom(goog.dom.TagName.DIV, null);
  wbrEl.innerHTML = textWbr;

  assertEquals(
      'text content should have wbr character removed', expectedText,
      goog.dom.getTextContent(wbrEl));
}
