Upload folder using huggingface_hub

1e92f2d verified over 1 year ago

5.73 kB

import React from "react";
import $ from "jquery";
import assign from "object-assign";
import { render } from "@testing-library/react";
import Slider from "../src/slider";
import { InnerSlider } from "../src/inner-slider";
import defaultProps from "../src/default-props";
import * as slickCarousel from "slick-carousel"; // defining slick in global environment
import { getTrackLeft } from "../src/utils/innerSliderUtils";
import {
  getActiveSlides,
  getActiveSlidesCount,
  clickNext,
  clickPrevious
} from "../test-utils";

// finds active slide number in the last transition in the forward direction
export function activeSlideInLastTransition(
  noOfSlides,
  slidesToShow,
  slidesToScroll
) {
  let currentSlide = 0;
  while (currentSlide < noOfSlides) {
    currentSlide += slidesToScroll;
  }
  return currentSlide - slidesToScroll;
}

// create jsx-form children for react slider
export function createReactSliderChildren(noOfSlides) {
  return Array.from(Array(noOfSlides).keys()).map(i => (
    <div key={i}>
      <h3>{i + 1}</h3>
    </div>
  ));
}

// create a react-slider with given noOfSlides and other props
// variable widths are ignored for now for simplicity
export function createReactSlider({ noOfSlides, ...props }) {
  return <Slider {...props}>{createReactSliderChildren(noOfSlides)}</Slider>;
}

// create a react inner-slider with given noOfSlides and other props
// performs most operations like the ones when mounted inside Slider component
export function createInnerSlider({ noOfSlides, ...settings }) {
  if (settings.centerMode) {
    settings.slidesToScroll = 1; // always scroll by one when centerMode is enabled
  }
  settings = assign({}, defaultProps, settings);
  const children = React.Children.toArray(
    createReactSliderChildren(noOfSlides)
  );
  return <InnerSlider {...settings}>{children}</InnerSlider>;
}

export function createInnerSliderWrapper(settings) {
  return render(createInnerSlider(settings)).container;
}

// creates a dom string, containing children of slick children
export function createJQuerySliderChildren(noOfSlides) {
  let children = [];
  for (let i = 0; i < noOfSlides; i++) {
    children.push(`<div><h3>${i + 1}</h3></div>`);
  }
  return children.join("");
}

// performs the very basic tests while clicking next or prev
export function testSliderScroll({ direction, ...settings }) {
  const { noOfSlides, slidesToShow, slidesToScroll, initialSlide } = settings;
  // initialize react slider
  const { container } = render(createReactSlider(settings));
  // initialize jquery slider
  document.body.innerHTML = `
  <section class="regular slider">
    ${createJQuerySliderChildren(noOfSlides)}
  </section>
  `;
  $(".regular.slider").slick({
    ...settings
  });
  // console.log('setings:', settings)

  let expectedSlideIndex = initialSlide || 0;
  for (let click = 0; click < 2 * noOfSlides + 2; click++) {
    let activeslides = getActiveSlides(container);
    let $activeSlides = $(".regular.slider").find("div.slick-active");
    expect(getActiveSlidesCount(container)).toEqual(slidesToShow || 1);
    expect($activeSlides.length).toEqual(slidesToShow || 1);
    let firstActiveSlide = activeslides[0];
    let $firstActiveSlide = $activeSlides.first();
    // console.log('classes', $firstActiveSlide.attr('data-slick-index'))
    // console.warn('currentSlide:', firstActiveSlide.prop('data-index'), 'expected slide', expectedSlideIndex)
    expect(parseInt(firstActiveSlide.getAttribute("data-index"))).toEqual(
      expectedSlideIndex % noOfSlides
    );
    expect(parseInt($firstActiveSlide.attr("data-slick-index"))).toEqual(
      expectedSlideIndex % noOfSlides
    );
    if (direction === "next") {
      // click the next arrow button
      clickNext(container);
      $("button.slick-next").click();
      expectedSlideIndex += slidesToScroll || 1;
      if (expectedSlideIndex >= noOfSlides) {
        expectedSlideIndex = 0;
      }
    } else {
      // click on the prev arrow button
      clickPrevious(container);
      $("button.slick-prev").click();
      expectedSlideIndex -= slidesToScroll || 1;
      if (expectedSlideIndex < 0) {
        expectedSlideIndex = activeSlideInLastTransition(
          noOfSlides,
          slidesToShow,
          slidesToScroll
        );
      }
    }
  }
}

// function to run tests on a slider,
// scrolls slider to the right by clicking right arrow several times
// scrolls slider to the left by clicking left arrow several times
export function testSlider(settings) {
  const settings1 = { direction: "next", ...settings };
  const settings2 = { direction: "prev", ...settings };
  testSliderScroll(settings1);
  testSliderScroll(settings2);
}

export const tryAllConfigs = (settings, settingsList) => {
  let leaf = true;
  for (let key of Object.keys(settings)) {
    if (Array.isArray(settings[key])) {
      leaf = false;
      for (let val of settings[key]) {
        tryAllConfigs({ ...settings, [key]: val }, settingsList);
      }
    }
  }
  if (leaf) {
    if (
      settingsList
        .map(setting => JSON.stringify(setting))
        .indexOf(JSON.stringify(settings)) < 0
    ) {
      settingsList.push(settings);
    }
  }
};

export const actualTrackLeft = container =>
  container
    .querySelector(".slick-track")
    .style.transform.match(/translate3d\((\d+)px/i)[1];

export const testTrackLeft = container => {
  let trackLeft = parseInt(actualTrackLeft(container));
  let spec = assign({}, wrapper.props(), wrapper.state(), {
    slideIndex: wrapper.state().currentSlide,
    trackRef: null
  });
  let expectedTrackLeft = getTrackLeft(spec);
  expect(trackLeft).toEqual(parseInt(expectedTrackLeft));
};
test("fake test", () => {
  expect(1).toBe(1);
});

	import React from "react";
	import $ from "jquery";
	import assign from "object-assign";
	import { render } from "@testing-library/react";
	import Slider from "../src/slider";
	import { InnerSlider } from "../src/inner-slider";
	import defaultProps from "../src/default-props";
	import * as slickCarousel from "slick-carousel"; // defining slick in global environment
	import { getTrackLeft } from "../src/utils/innerSliderUtils";
	import {
	getActiveSlides,
	getActiveSlidesCount,
	clickNext,
	clickPrevious
	} from "../test-utils";

	// finds active slide number in the last transition in the forward direction
	export function activeSlideInLastTransition(
	noOfSlides,
	slidesToShow,
	slidesToScroll
	) {
	let currentSlide = 0;
	while (currentSlide < noOfSlides) {
	currentSlide += slidesToScroll;
	}
	return currentSlide - slidesToScroll;
	}

	// create jsx-form children for react slider
	export function createReactSliderChildren(noOfSlides) {
	return Array.from(Array(noOfSlides).keys()).map(i => (
	<div key={i}>
	<h3>{i + 1}</h3>
	</div>
	));
	}

	// create a react-slider with given noOfSlides and other props
	// variable widths are ignored for now for simplicity
	export function createReactSlider({ noOfSlides, ...props }) {
	return <Slider {...props}>{createReactSliderChildren(noOfSlides)}</Slider>;
	}

	// create a react inner-slider with given noOfSlides and other props
	// performs most operations like the ones when mounted inside Slider component
	export function createInnerSlider({ noOfSlides, ...settings }) {
	if (settings.centerMode) {
	settings.slidesToScroll = 1; // always scroll by one when centerMode is enabled
	}
	settings = assign({}, defaultProps, settings);
	const children = React.Children.toArray(
	createReactSliderChildren(noOfSlides)
	);
	return <InnerSlider {...settings}>{children}</InnerSlider>;
	}

	export function createInnerSliderWrapper(settings) {
	return render(createInnerSlider(settings)).container;
	}

	// creates a dom string, containing children of slick children
	export function createJQuerySliderChildren(noOfSlides) {
	let children = [];
	for (let i = 0; i < noOfSlides; i++) {
	children.push(`<div><h3>${i + 1}</h3></div>`);
	}
	return children.join("");
	}

	// performs the very basic tests while clicking next or prev
	export function testSliderScroll({ direction, ...settings }) {
	const { noOfSlides, slidesToShow, slidesToScroll, initialSlide } = settings;
	// initialize react slider
	const { container } = render(createReactSlider(settings));
	// initialize jquery slider
	document.body.innerHTML = `
	<section class="regular slider">
	${createJQuerySliderChildren(noOfSlides)}
	</section>
	`;
	$(".regular.slider").slick({
	...settings
	});
	// console.log('setings:', settings)

	let expectedSlideIndex = initialSlide \|\| 0;
	for (let click = 0; click < 2 * noOfSlides + 2; click++) {
	let activeslides = getActiveSlides(container);
	let $activeSlides = $(".regular.slider").find("div.slick-active");
	expect(getActiveSlidesCount(container)).toEqual(slidesToShow \|\| 1);
	expect($activeSlides.length).toEqual(slidesToShow \|\| 1);
	let firstActiveSlide = activeslides[0];
	let $firstActiveSlide = $activeSlides.first();
	// console.log('classes', $firstActiveSlide.attr('data-slick-index'))
	// console.warn('currentSlide:', firstActiveSlide.prop('data-index'), 'expected slide', expectedSlideIndex)
	expect(parseInt(firstActiveSlide.getAttribute("data-index"))).toEqual(
	expectedSlideIndex % noOfSlides
	);
	expect(parseInt($firstActiveSlide.attr("data-slick-index"))).toEqual(
	expectedSlideIndex % noOfSlides
	);
	if (direction === "next") {
	// click the next arrow button
	clickNext(container);
	$("button.slick-next").click();
	expectedSlideIndex += slidesToScroll \|\| 1;
	if (expectedSlideIndex >= noOfSlides) {
	expectedSlideIndex = 0;
	}
	} else {
	// click on the prev arrow button
	clickPrevious(container);
	$("button.slick-prev").click();
	expectedSlideIndex -= slidesToScroll \|\| 1;
	if (expectedSlideIndex < 0) {
	expectedSlideIndex = activeSlideInLastTransition(
	noOfSlides,
	slidesToShow,
	slidesToScroll
	);
	}
	}
	}
	}

	// function to run tests on a slider,
	// scrolls slider to the right by clicking right arrow several times
	// scrolls slider to the left by clicking left arrow several times
	export function testSlider(settings) {
	const settings1 = { direction: "next", ...settings };
	const settings2 = { direction: "prev", ...settings };
	testSliderScroll(settings1);
	testSliderScroll(settings2);
	}

	export const tryAllConfigs = (settings, settingsList) => {
	let leaf = true;
	for (let key of Object.keys(settings)) {
	if (Array.isArray(settings[key])) {
	leaf = false;
	for (let val of settings[key]) {
	tryAllConfigs({ ...settings, [key]: val }, settingsList);
	}
	}
	}
	if (leaf) {
	if (
	settingsList
	.map(setting => JSON.stringify(setting))
	.indexOf(JSON.stringify(settings)) < 0
	) {
	settingsList.push(settings);
	}
	}
	};

	export const actualTrackLeft = container =>
	container
	.querySelector(".slick-track")
	.style.transform.match(/translate3d\((\d+)px/i)[1];

	export const testTrackLeft = container => {
	let trackLeft = parseInt(actualTrackLeft(container));
	let spec = assign({}, wrapper.props(), wrapper.state(), {
	slideIndex: wrapper.state().currentSlide,
	trackRef: null
	});
	let expectedTrackLeft = getTrackLeft(spec);
	expect(trackLeft).toEqual(parseInt(expectedTrackLeft));
	};
	test("fake test", () => {
	expect(1).toBe(1);
	});