From 41988f0df69adc0826ec0a91b8897be0fc881b02 Mon Sep 17 00:00:00 2001
From: Damimani <dani.toth2003@gmail.com>
Date: Sun, 1 Nov 2026 18:30:58 +0100
Subject: [PATCH] feladat4v2

---
 feladat4/UnitTest1/UnitTest1.cpp        | 274 ++++++++++++++++++------
 feladat4/feladat4/IFPQYY_feladat4V2.zip | Bin 0 -> 4582 bytes
 feladat4/feladat4/UnitTest1.cpp         | 244 +++++++++++++++++++++
 feladat4/feladat4/cmydate.cpp           |  94 ++++----
 feladat4/feladat4/cmydate.h             |   2 +-
 feladat4/feladat4/cmydateexception.cpp  |   2 +-
 feladat4/feladat4/cmydateexception.h    |   2 +-
 feladat4/feladat4/main.cpp              |   2 +-
 8 files changed, 507 insertions(+), 113 deletions(-)
 create mode 100644 feladat4/feladat4/IFPQYY_feladat4V2.zip
 create mode 100644 feladat4/feladat4/UnitTest1.cpp

diff --git a/feladat4/UnitTest1/UnitTest1.cpp b/feladat4/UnitTest1/UnitTest1.cpp
index 5b2a5bc..afec52c 100644
--- a/feladat4/UnitTest1/UnitTest1.cpp
+++ b/feladat4/UnitTest1/UnitTest1.cpp
@@ -1,9 +1,12 @@
+//Tóth Dániel Mátyás | IFPQYY | V2
 #include "pch.h"
 #include "CppUnitTest.h"
+#include <iostream>
 #include <cmydate.h>
 #include <cmydateexception.h>
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace std;
 
 namespace UnitTest1
 {
@@ -11,86 +14,231 @@ namespace UnitTest1
 	{
 	public:
 		
-
-		TEST_METHOD(ValidDate)
+		TEST_METHOD(ValidDates)
 		{
 			CMyDate date;
-			Assert::AreEqual(true, date.IsValid(1980, 4, 23));
-			Assert::AreEqual(true, date.IsValid(1970, 1, 31));
-			Assert::AreEqual(true, date.IsValid(1970, 2, 28));
-			Assert::AreEqual(true, date.IsValid(1970, 9, 30));
-			Assert::AreEqual(true, date.IsValid(1972, 2, 29));
+			int dates[][3] = {
+				{ 1980, 4, 23 },
+				{ 1970, 1, 31 },
+				{ 1970, 9, 30 },
+				{ 1970, 2, 28 },
+				{ 1972, 2, 29 },
+				{ 2000, 2, 29 },
+			};
+			int testcount = sizeof(dates) / 12;
+			for (size_t i = 0; i < testcount; i++)
+			{
+				Assert::AreEqual(true, date.IsValid(dates[i][0], dates[i][1], dates[i][2]));
+			}
 		}
 
 		TEST_METHOD(InvalidDates)
 		{
 			CMyDate date;
-			
-			try
+			int dates[][3] = {
+				{ 1969, 1, 1 },
+				{ 1970, 0, 1 },
+				{ 1970, 13, 1 },
+				{ 1970, 1, 0 },
+				{ 1970, 1, 32 },
+				{ 1970, 9, 31 },
+				{ 1970, 2, 29 },
+				{ 2100, 2, 29 },
+			};
+			const char* errors[] = {
+				CMyDateException::ErrMinYear,
+				CMyDateException::ErrMinMonth,
+				CMyDateException::ErrMaxMonth,
+				CMyDateException::ErrMinDay,
+				CMyDateException::ErrMaxDay,
+				CMyDateException::ErrMaxDay,
+				CMyDateException::ErrMaxDay,
+				CMyDateException::ErrMaxDay,
+			};
+			int testcount = sizeof(dates) / 12;
+			for (size_t i = 0; i < testcount; i++)
 			{
-				date.IsValid(1969, 1, 1);
-				Assert::IsTrue(false);
+				Assert::IsFalse(date.IsValid(dates[i][0], dates[i][1], dates[i][2]));
 			}
-			catch (const CMyDateException &e)
+		}
+		TEST_METHOD(DayOfTheYearTests)
+		{
+			CMyDate date;
+			int dates[][3] = {
+				{ 1970, 1, 1 },
+				{ 1970, 2, 3 },
+				{ 1970, 3, 1 }, //non-leap year
+				{ 1972, 3, 1 }, //leap year
+			};
+			int counts[] = {
+				1,
+				34,
+				60,
+				61,
+			};
+			int testcount = sizeof(dates) / 12;
+			for (size_t i = 0; i < testcount; i++)
 			{
-				Assert::AreEqual(CMyDateException::ErrMinYear, e.what());
+				date = CMyDate(dates[i][0], dates[i][1], dates[i][2]);
+				Assert::AreEqual(counts[i], date.DayOfTheYear());
 			}
-			try
+		}
+
+		TEST_METHOD(AddDayTests)
+		{
+			CMyDate date1;
+			CMyDate date2;
+			int dates1[][3] = {
+				{ 1970, 1, 1 },
+				{ 1970, 1, 1 },
+				{ 1970, 2, 1 },
+				{ 1972, 2, 1 },
+				{ 1970, 1, 1 },
+				{ 1972, 1, 1 },
+				{ 1970, 1, 2 },
+				{ 1970, 1, 1 },
+			};
+			int dates2[][3] = { //expected
+				{ 1970, 1, 2 },
+				{ 1970, 2, 1 },
+				{ 1970, 3, 1 },
+				{ 1972, 2, 29 },
+				{ 1971, 1, 1 },
+				{ 1972, 12, 31 },
+				{ 1970, 1, 1 },
+				{ 1970, 1, 1 },
+			};
+			int counts[] = {
+				1,
+				31,
+				28,
+				28,
+				365,
+				365,
+				-1, //technically allowed
+				- 1 //since SubDays calls AddDays, this counts as its test
+			};
+			int testcount = sizeof(dates1) / 12;
+			for (size_t i = 0; i < testcount; i++)
 			{
-				date = CMyDate(1970, 0, 1);
+				try
+				{
+					CMyDate date1 = CMyDate(dates1[i][0], dates1[i][1], dates1[i][2]);
+					CMyDate date2 = CMyDate(dates2[i][0], dates2[i][1], dates2[i][2]);
+					date1.AddDays(counts[i]);
+					Assert::AreEqual(date2.GetYear(), date1.GetYear());
+					Assert::AreEqual(date2.GetMonth(), date1.GetMonth());
+					Assert::AreEqual(date2.GetDay(), date1.GetDay());
+				}
+				catch (const CMyDateException& e)
+				{
+					Assert::AreEqual(CMyDateException::ErrMinYear, e.what()); //should only happen in the last case
+				}
+				catch (...) {
+					Assert::IsTrue(false);
+				}
 			}
-			catch (CMyDateException e)
+		}
+
+		TEST_METHOD(DifferenceInDaysTests)
+		{
+			CMyDate date1;
+			CMyDate date2;
+			int diff = 0;
+
+			int dates1[][3] = {
+				{ 1970, 1, 1 },
+				{ 1970, 1, 1 },
+				{ 1972, 1, 1 },
+				{ 1970, 1, 1 },
+				{ 1972, 1, 1 },
+				{ 1970, 1, 1 },
+			};
+			int dates2[][3] = {
+				{ 1970, 1, 1 },
+				{ 1970, 3, 1 },
+				{ 1972, 3, 1 },
+				{ 1971, 1, 1 },
+				{ 1973, 1, 1 },
+				{ 1974, 1, 1 },
+			};
+			int counts[] = {
+				0,
+				-59,
+				-60,
+				-365,
+				-366,
+				-1461
+			};
+			int testcount = sizeof(dates1)/12;
+			for (size_t i = 0; i < testcount; i++)
 			{
-				Assert::AreEqual(CMyDateException::ErrMinMonth, e.what());
+				CMyDate date1 = CMyDate(dates1[i][0], dates1[i][1], dates1[i][2]);
+				CMyDate date2 = CMyDate(dates2[i][0], dates2[i][1], dates2[i][2]);
+				diff = date1.DifferenceInDays(date2);
+				Assert::AreEqual(counts[i], diff);
+				diff = date2.DifferenceInDays(date1); //should be different in reverse ig
+				Assert::AreEqual(counts[i] * (-1), diff);
 			}
-			try
+		}
+
+		TEST_METHOD(AddMonthTests)
+		{
+			CMyDate date1;
+			CMyDate date2;
+			int dates1[][3] = {
+				{ 1970, 1, 1 },
+				{ 1970, 1, 1 },
+				{ 1970, 1, 10 },
+				{ 1970, 12, 1 },
+				{ 1970, 1, 30 },
+				{ 1970, 1, 1 },
+			};
+			int dates2[][3] = {
+				{ 1970, 2, 1 },
+				{ 1970, 3, 1 },
+				{ 1970, 2, 10 },
+				{ 1971, 1, 1 },
+				{ 1970, 1, 30 },
+				{ 1971, 1, 1 },
+			};
+			int counts[] = {
+				1,
+				2,
+				1,
+				1,
+				1,
+				12,
+			};
+			int testcount = sizeof(dates1) / 12;
+			for (size_t i = 0; i < testcount; i++)
 			{
-				date = CMyDate(1970, 13, 1);
-			}
-			catch (CMyDateException e)
-			{
-				Assert::AreEqual(CMyDateException::ErrMaxMonth, e.what());
-			}
-			try
-			{
-				date = CMyDate(1970, 1, 0);
-			}
-			catch (CMyDateException e)
-			{
-				Assert::AreEqual(CMyDateException::ErrMinDay, e.what());
-			}
-			try
-			{
-				date = CMyDate(1970, 1, 32);
-			}
-			catch (CMyDateException e)
-			{
-				Assert::AreEqual(CMyDateException::ErrMaxDay, e.what());
-			}
-			try
-			{
-				date = CMyDate(1970, 9, 31);
-			}
-			catch (CMyDateException e)
-			{
-				Assert::AreEqual(CMyDateException::ErrMaxDay, e.what());
-			}
-			try
-			{
-				date = CMyDate(1970, 4, 29);
-			}
-			catch (CMyDateException e)
-			{
-				Assert::AreEqual(CMyDateException::ErrMaxDay, e.what());
-			}
-			try
-			{
-				date = CMyDate(2000, 4, 29);
-			}
-			catch (CMyDateException e)
-			{
-				Assert::AreEqual(CMyDateException::ErrMaxDay, e.what());
+				CMyDate date1 = CMyDate(dates1[i][0], dates1[i][1], dates1[i][2]);
+				CMyDate date2 = CMyDate(dates2[i][0], dates2[i][1], dates2[i][2]);
+				try
+				{
+					date1.AddMonths(counts[i]);
+				}
+				catch (const CMyDateException& e)
+				{
+					Assert::AreEqual(CMyDateException::ErrMaxDay, e.what());
+				}
+				Assert::AreEqual(date2.GetYear(), date1.GetYear());
+				Assert::AreEqual(date2.GetMonth(), date1.GetMonth());
+				Assert::AreEqual(date2.GetDay(), date1.GetDay());
 			}
 		}
+		TEST_METHOD(DisplayTests) {
+			CMyDate date;
+
+			stringstream buff;
+			streambuf* prevcoutbuff = cout.rdbuf(buff.rdbuf());
+			date = CMyDate(1970, 1, 1);
+			date.Display();
+
+			string d = buff.str();
+
+			Assert::IsTrue(d == "1970 januar 1.");
+		}
 	};
 }
diff --git a/feladat4/feladat4/IFPQYY_feladat4V2.zip b/feladat4/feladat4/IFPQYY_feladat4V2.zip
new file mode 100644
index 0000000000000000000000000000000000000000..6596df5b04e461ad8f055e579f9c6bbc0bc66ce7
GIT binary patch
literal 4582
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

literal 0
HcmV?d00001

diff --git a/feladat4/feladat4/UnitTest1.cpp b/feladat4/feladat4/UnitTest1.cpp
new file mode 100644
index 0000000..afec52c
--- /dev/null
+++ b/feladat4/feladat4/UnitTest1.cpp
@@ -0,0 +1,244 @@
+//Tóth Dániel Mátyás | IFPQYY | V2
+#include "pch.h"
+#include "CppUnitTest.h"
+#include <iostream>
+#include <cmydate.h>
+#include <cmydateexception.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+using namespace std;
+
+namespace UnitTest1
+{
+	TEST_CLASS(UnitTest1)
+	{
+	public:
+		
+		TEST_METHOD(ValidDates)
+		{
+			CMyDate date;
+			int dates[][3] = {
+				{ 1980, 4, 23 },
+				{ 1970, 1, 31 },
+				{ 1970, 9, 30 },
+				{ 1970, 2, 28 },
+				{ 1972, 2, 29 },
+				{ 2000, 2, 29 },
+			};
+			int testcount = sizeof(dates) / 12;
+			for (size_t i = 0; i < testcount; i++)
+			{
+				Assert::AreEqual(true, date.IsValid(dates[i][0], dates[i][1], dates[i][2]));
+			}
+		}
+
+		TEST_METHOD(InvalidDates)
+		{
+			CMyDate date;
+			int dates[][3] = {
+				{ 1969, 1, 1 },
+				{ 1970, 0, 1 },
+				{ 1970, 13, 1 },
+				{ 1970, 1, 0 },
+				{ 1970, 1, 32 },
+				{ 1970, 9, 31 },
+				{ 1970, 2, 29 },
+				{ 2100, 2, 29 },
+			};
+			const char* errors[] = {
+				CMyDateException::ErrMinYear,
+				CMyDateException::ErrMinMonth,
+				CMyDateException::ErrMaxMonth,
+				CMyDateException::ErrMinDay,
+				CMyDateException::ErrMaxDay,
+				CMyDateException::ErrMaxDay,
+				CMyDateException::ErrMaxDay,
+				CMyDateException::ErrMaxDay,
+			};
+			int testcount = sizeof(dates) / 12;
+			for (size_t i = 0; i < testcount; i++)
+			{
+				Assert::IsFalse(date.IsValid(dates[i][0], dates[i][1], dates[i][2]));
+			}
+		}
+		TEST_METHOD(DayOfTheYearTests)
+		{
+			CMyDate date;
+			int dates[][3] = {
+				{ 1970, 1, 1 },
+				{ 1970, 2, 3 },
+				{ 1970, 3, 1 }, //non-leap year
+				{ 1972, 3, 1 }, //leap year
+			};
+			int counts[] = {
+				1,
+				34,
+				60,
+				61,
+			};
+			int testcount = sizeof(dates) / 12;
+			for (size_t i = 0; i < testcount; i++)
+			{
+				date = CMyDate(dates[i][0], dates[i][1], dates[i][2]);
+				Assert::AreEqual(counts[i], date.DayOfTheYear());
+			}
+		}
+
+		TEST_METHOD(AddDayTests)
+		{
+			CMyDate date1;
+			CMyDate date2;
+			int dates1[][3] = {
+				{ 1970, 1, 1 },
+				{ 1970, 1, 1 },
+				{ 1970, 2, 1 },
+				{ 1972, 2, 1 },
+				{ 1970, 1, 1 },
+				{ 1972, 1, 1 },
+				{ 1970, 1, 2 },
+				{ 1970, 1, 1 },
+			};
+			int dates2[][3] = { //expected
+				{ 1970, 1, 2 },
+				{ 1970, 2, 1 },
+				{ 1970, 3, 1 },
+				{ 1972, 2, 29 },
+				{ 1971, 1, 1 },
+				{ 1972, 12, 31 },
+				{ 1970, 1, 1 },
+				{ 1970, 1, 1 },
+			};
+			int counts[] = {
+				1,
+				31,
+				28,
+				28,
+				365,
+				365,
+				-1, //technically allowed
+				- 1 //since SubDays calls AddDays, this counts as its test
+			};
+			int testcount = sizeof(dates1) / 12;
+			for (size_t i = 0; i < testcount; i++)
+			{
+				try
+				{
+					CMyDate date1 = CMyDate(dates1[i][0], dates1[i][1], dates1[i][2]);
+					CMyDate date2 = CMyDate(dates2[i][0], dates2[i][1], dates2[i][2]);
+					date1.AddDays(counts[i]);
+					Assert::AreEqual(date2.GetYear(), date1.GetYear());
+					Assert::AreEqual(date2.GetMonth(), date1.GetMonth());
+					Assert::AreEqual(date2.GetDay(), date1.GetDay());
+				}
+				catch (const CMyDateException& e)
+				{
+					Assert::AreEqual(CMyDateException::ErrMinYear, e.what()); //should only happen in the last case
+				}
+				catch (...) {
+					Assert::IsTrue(false);
+				}
+			}
+		}
+
+		TEST_METHOD(DifferenceInDaysTests)
+		{
+			CMyDate date1;
+			CMyDate date2;
+			int diff = 0;
+
+			int dates1[][3] = {
+				{ 1970, 1, 1 },
+				{ 1970, 1, 1 },
+				{ 1972, 1, 1 },
+				{ 1970, 1, 1 },
+				{ 1972, 1, 1 },
+				{ 1970, 1, 1 },
+			};
+			int dates2[][3] = {
+				{ 1970, 1, 1 },
+				{ 1970, 3, 1 },
+				{ 1972, 3, 1 },
+				{ 1971, 1, 1 },
+				{ 1973, 1, 1 },
+				{ 1974, 1, 1 },
+			};
+			int counts[] = {
+				0,
+				-59,
+				-60,
+				-365,
+				-366,
+				-1461
+			};
+			int testcount = sizeof(dates1)/12;
+			for (size_t i = 0; i < testcount; i++)
+			{
+				CMyDate date1 = CMyDate(dates1[i][0], dates1[i][1], dates1[i][2]);
+				CMyDate date2 = CMyDate(dates2[i][0], dates2[i][1], dates2[i][2]);
+				diff = date1.DifferenceInDays(date2);
+				Assert::AreEqual(counts[i], diff);
+				diff = date2.DifferenceInDays(date1); //should be different in reverse ig
+				Assert::AreEqual(counts[i] * (-1), diff);
+			}
+		}
+
+		TEST_METHOD(AddMonthTests)
+		{
+			CMyDate date1;
+			CMyDate date2;
+			int dates1[][3] = {
+				{ 1970, 1, 1 },
+				{ 1970, 1, 1 },
+				{ 1970, 1, 10 },
+				{ 1970, 12, 1 },
+				{ 1970, 1, 30 },
+				{ 1970, 1, 1 },
+			};
+			int dates2[][3] = {
+				{ 1970, 2, 1 },
+				{ 1970, 3, 1 },
+				{ 1970, 2, 10 },
+				{ 1971, 1, 1 },
+				{ 1970, 1, 30 },
+				{ 1971, 1, 1 },
+			};
+			int counts[] = {
+				1,
+				2,
+				1,
+				1,
+				1,
+				12,
+			};
+			int testcount = sizeof(dates1) / 12;
+			for (size_t i = 0; i < testcount; i++)
+			{
+				CMyDate date1 = CMyDate(dates1[i][0], dates1[i][1], dates1[i][2]);
+				CMyDate date2 = CMyDate(dates2[i][0], dates2[i][1], dates2[i][2]);
+				try
+				{
+					date1.AddMonths(counts[i]);
+				}
+				catch (const CMyDateException& e)
+				{
+					Assert::AreEqual(CMyDateException::ErrMaxDay, e.what());
+				}
+				Assert::AreEqual(date2.GetYear(), date1.GetYear());
+				Assert::AreEqual(date2.GetMonth(), date1.GetMonth());
+				Assert::AreEqual(date2.GetDay(), date1.GetDay());
+			}
+		}
+		TEST_METHOD(DisplayTests) {
+			CMyDate date;
+
+			stringstream buff;
+			streambuf* prevcoutbuff = cout.rdbuf(buff.rdbuf());
+			date = CMyDate(1970, 1, 1);
+			date.Display();
+
+			string d = buff.str();
+
+			Assert::IsTrue(d == "1970 januar 1.");
+		}
+	};
+}
diff --git a/feladat4/feladat4/cmydate.cpp b/feladat4/feladat4/cmydate.cpp
index 37c8727..11af7b3 100644
--- a/feladat4/feladat4/cmydate.cpp
+++ b/feladat4/feladat4/cmydate.cpp
@@ -1,4 +1,4 @@
-//Tóth Dániel Mátyás | IFPQYY | V1
+//Tóth Dániel Mátyás | IFPQYY | V2
 #include <iostream>
 #include "cmydateexception.h"
 #include "cmydate.h"
@@ -6,18 +6,18 @@
 using namespace std;
 
 static char monthnames[12][11] = {
-	"Január",
-	"Február",
-	"Március",
-	"Április",
-	"Május",
-	"Június",
-	"Július",
-	"Augusztus",
-	"Szeptember",
-	"Október",
-	"November",
-	"December"
+	"januar",
+	"februar",
+	"március",
+	"aprilis",
+	"majus",
+	"junius",
+	"julius",
+	"augusztus",
+	"szeptember",
+	"oktober",
+	"november",
+	"december"
 };
 
 static bool IsLeapYear(int year);
@@ -30,14 +30,15 @@ static void TimeStampToDate(int timestamp, int* year, int* month, int* day);
 static int DayOfTheYearArgs(int year, int month, int day);
 
 CMyDate::CMyDate() {
-	SetYear(1970);
-	SetMonth(1);
-	SetDay(1);
+	m_iYear = 1970;
+	m_iMonth = 1;
+	m_iDay = 1;
 }
 CMyDate::CMyDate(int year, int month, int day) {
-	SetYear(year);
-	SetMonth(month);
-	SetDay(day);
+	IsValid(year, month, day);
+	m_iYear = year;
+	m_iMonth = month;
+	m_iDay = day;
 }
 CMyDate::~CMyDate(){
 	//hey jimmy, get me a destructor with nothing
@@ -49,19 +50,32 @@ int CMyDate::DayOfTheYear() const {
 	return DayOfTheYearArgs(GetYear(), GetMonth(), GetDay());
 }
 bool CMyDate::IsValid(int year, int month, int day) const {
-	IsValidYear(year);
-	IsValidMonth(month);
-	IsValidDay(year, month, day);
+	try
+	{
+		IsValidYear(year);
+		IsValidMonth(month);
+		IsValidDay(year, month, day);
+	}
+	catch (const CMyDateException&)
+	{
+		return false;
+	}
 	return true;
 }
 void CMyDate::AddDays(int days) {
+	if (days == 0)
+	{
+		return;
+	}
 	int timestamp = DateToTimeStamp(GetYear(), GetMonth(), GetDay());
 	int y = 0, m = 0, d = 0;
 	TimeStampToDate(timestamp + days, &y, &m, &d);
-	IsValid(y, m, d);
-	m_iYear = y;
-	m_iMonth = m;
-	m_iDay = d;
+	if (IsValid(y, m, d))
+	{
+		m_iYear = y;
+		m_iMonth = m;
+		m_iDay = d;
+	}
 }
 void CMyDate::SubDays(int days) {
 	AddDays(days * (-1));
@@ -70,26 +84,14 @@ int CMyDate::DifferenceInDays(const CMyDate& other) const {
 	int thistmstmp = DateToTimeStamp(GetYear(), GetMonth(), GetDay());
 	int othertmstmp = DateToTimeStamp(other.GetYear(), other.GetMonth(), other.GetDay());
 	int result = thistmstmp - othertmstmp;
-	return result < 0 ? result * (-1) : result;
+	return result;
 }
 void CMyDate::AddMonths(int months) {
-	m_iYear += (m_iMonth - 1 + months) / 12;
-	m_iMonth += ((m_iMonth - 1 + months) % 12) + 1;
-	try
-	{
-		IsValidDay(m_iYear, m_iMonth, m_iDay);
-	}
-	catch (CMyDateException e)
-	{
-		if (e.what() == CMyDateException::ErrMaxDay)
-		{
-			SetDay(GetMonthDayCount(m_iMonth, m_iYear));
-		}
-		else
-		{
-			throw e;
-		}
-	}
+	int y = m_iYear + (m_iMonth - 1 + months) / 12;
+	int m = ((m_iMonth - 1 + months) % 12) + 1;
+	IsValidDay(y, m, m_iDay);
+	m_iYear = y;
+	m_iMonth = m;
 }
 int CMyDate::GetDay() const {
 	return m_iDay;
@@ -107,13 +109,13 @@ void CMyDate::SetDay(int day) {
 	}
 }
 void CMyDate::SetMonth(int month) {
-	if (IsValidMonth(month))
+	if (IsValidMonth(month) && IsValidDay(m_iYear, month, m_iDay))
 	{
 		m_iMonth = month;
 	}
 }
 void CMyDate::SetYear(int year) {
-	if (IsValidYear(year))
+	if (IsValidYear(year) && IsValidDay(year, m_iMonth, m_iDay))
 	{
 		m_iYear = year;
 	}
diff --git a/feladat4/feladat4/cmydate.h b/feladat4/feladat4/cmydate.h
index ba7e6df..5f82d40 100644
--- a/feladat4/feladat4/cmydate.h
+++ b/feladat4/feladat4/cmydate.h
@@ -1,4 +1,4 @@
-//Tóth Dániel Mátyás | IFPQYY | V1
+//Tóth Dániel Mátyás | IFPQYY | V2
 #pragma once
 class CMyDate {
 public:
diff --git a/feladat4/feladat4/cmydateexception.cpp b/feladat4/feladat4/cmydateexception.cpp
index c9f8874..1c3e0cd 100644
--- a/feladat4/feladat4/cmydateexception.cpp
+++ b/feladat4/feladat4/cmydateexception.cpp
@@ -1,4 +1,4 @@
-//Tóth Dániel Mátyás | IFPQYY | V1
+//Tóth Dániel Mátyás | IFPQYY | V2
 #include "cmydateexception.h"
 
 static int CopyStr(char* dest, const char* src, const char* concat = "\0") {
diff --git a/feladat4/feladat4/cmydateexception.h b/feladat4/feladat4/cmydateexception.h
index c32e3c8..728d3e4 100644
--- a/feladat4/feladat4/cmydateexception.h
+++ b/feladat4/feladat4/cmydateexception.h
@@ -1,4 +1,4 @@
-//Tóth Dániel Mátyás | IFPQYY | V1
+//Tóth Dániel Mátyás | IFPQYY | V2
 #pragma once
 class CMyDateException {
 public:
diff --git a/feladat4/feladat4/main.cpp b/feladat4/feladat4/main.cpp
index aea7482..efd24c0 100644
--- a/feladat4/feladat4/main.cpp
+++ b/feladat4/feladat4/main.cpp
@@ -1,4 +1,4 @@
-//Tóth Dániel Mátyás | IFPQYY | V1
+//Tóth Dániel Mátyás | IFPQYY | V2
 #include <exception>
 #include <iostream>
 #include "cmydateexception.h"